snowflake-ml-python 1.20.0__py3-none-any.whl → 1.22.0__py3-none-any.whl

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

@@ -1,6 +1,4 @@
 import dataclasses
-import enum
-import hashlib
 import logging
 import pathlib
 import re
@@ -11,11 +9,12 @@ import warnings
 from typing import Any, Optional, Union, cast
 
 from snowflake import snowpark
-from snowflake.ml import jobs
 from snowflake.ml._internal import file_utils, platform_capabilities as pc
 from snowflake.ml._internal.utils import identifier, service_logger, sql_identifier
+from snowflake.ml.jobs import job
 from snowflake.ml.model import inference_engine as inference_engine_module, type_hints
 from snowflake.ml.model._client.model import batch_inference_specs
+from snowflake.ml.model._client.ops import deployment_step
 from snowflake.ml.model._client.service import model_deployment_spec
 from snowflake.ml.model._client.sql import service as service_sql, stage as stage_sql
 from snowflake.snowpark import async_job, exceptions, row, session
@@ -25,32 +24,12 @@ module_logger = service_logger.get_logger(__name__, service_logger.LogColor.GREY
 module_logger.propagate = False
 
 
-class DeploymentStep(enum.Enum):
-    MODEL_BUILD = ("model-build", "model_build_")
-    MODEL_INFERENCE = ("model-inference", None)
-    MODEL_LOGGING = ("model-logging", "model_logging_")
-
-    def __init__(self, container_name: str, service_name_prefix: Optional[str]) -> None:
-        self._container_name = container_name
-        self._service_name_prefix = service_name_prefix
-
-    @property
-    def container_name(self) -> str:
-        """Get the container name for the deployment step."""
-        return self._container_name
-
-    @property
-    def service_name_prefix(self) -> Optional[str]:
-        """Get the service name prefix for the deployment step."""
-        return self._service_name_prefix
-
-
 @dataclasses.dataclass
 class ServiceLogInfo:
     database_name: Optional[sql_identifier.SqlIdentifier]
     schema_name: Optional[sql_identifier.SqlIdentifier]
     service_name: sql_identifier.SqlIdentifier
-    deployment_step: DeploymentStep
+    deployment_step: deployment_step.DeploymentStep
     instance_id: str = "0"
     log_color: service_logger.LogColor = service_logger.LogColor.GREY
 
@@ -171,6 +150,7 @@ class ServiceOperator:
             self._model_deployment_spec = model_deployment_spec.ModelDeploymentSpec(
                 workspace_path=pathlib.Path(self._workspace.name)
             )
+        self._inference_autocapture_enabled = pc.PlatformCapabilities.get_instance().is_inference_autocapture_enabled()
 
     def __eq__(self, __value: object) -> bool:
         if not isinstance(__value, ServiceOperator):
@@ -207,7 +187,7 @@ class ServiceOperator:
         # inference engine model
         inference_engine_args: Optional[InferenceEngineArgs] = None,
         # inference table
-        autocapture: Optional[bool] = None,
+        autocapture: bool = False,
     ) -> Union[str, async_job.AsyncJob]:
 
         # Generate operation ID for this deployment
@@ -231,6 +211,10 @@ class ServiceOperator:
         progress_status.update("preparing deployment artifacts...")
         progress_status.increment()
 
+        # If autocapture param is disabled, don't allow create service with autocapture
+        if not self._inference_autocapture_enabled and autocapture:
+            raise ValueError("Invalid Argument: Autocapture feature is not supported.")
+
         if self._workspace:
             stage_path = self._create_temp_stage(database_name, schema_name, statement_params)
         else:
@@ -348,13 +332,16 @@ class ServiceOperator:
         if is_enable_image_build:
             # stream service logs in a thread
             model_build_service_name = sql_identifier.SqlIdentifier(
-                self._get_service_id_from_deployment_step(query_id, DeploymentStep.MODEL_BUILD)
+                deployment_step.get_service_id_from_deployment_step(
+                    query_id,
+                    deployment_step.DeploymentStep.MODEL_BUILD,
+                )
             )
             model_build_service = ServiceLogInfo(
                 database_name=service_database_name,
                 schema_name=service_schema_name,
                 service_name=model_build_service_name,
-                deployment_step=DeploymentStep.MODEL_BUILD,
+                deployment_step=deployment_step.DeploymentStep.MODEL_BUILD,
                 log_color=service_logger.LogColor.GREEN,
             )
 
@@ -362,21 +349,23 @@ class ServiceOperator:
             database_name=service_database_name,
             schema_name=service_schema_name,
             service_name=service_name,
-            deployment_step=DeploymentStep.MODEL_INFERENCE,
+            deployment_step=deployment_step.DeploymentStep.MODEL_INFERENCE,
             log_color=service_logger.LogColor.BLUE,
         )
 
         model_logger_service: Optional[ServiceLogInfo] = None
         if hf_model_args:
             model_logger_service_name = sql_identifier.SqlIdentifier(
-                self._get_service_id_from_deployment_step(query_id, DeploymentStep.MODEL_LOGGING)
+                deployment_step.get_service_id_from_deployment_step(
+                    query_id, deployment_step.DeploymentStep.MODEL_LOGGING
+                )
             )
 
             model_logger_service = ServiceLogInfo(
                 database_name=service_database_name,
                 schema_name=service_schema_name,
                 service_name=model_logger_service_name,
-                deployment_step=DeploymentStep.MODEL_LOGGING,
+                deployment_step=deployment_step.DeploymentStep.MODEL_LOGGING,
                 log_color=service_logger.LogColor.ORANGE,
             )
 
@@ -531,7 +520,7 @@ class ServiceOperator:
         service = service_log_meta.service
         # check if using an existing model build image
         if (
-            service.deployment_step == DeploymentStep.MODEL_BUILD
+            service.deployment_step == deployment_step.DeploymentStep.MODEL_BUILD
             and not force_rebuild
             and service_log_meta.is_model_logger_service_done
             and not service_log_meta.is_model_build_service_done
@@ -577,16 +566,16 @@ class ServiceOperator:
         if (service_status != service_sql.ServiceStatus.RUNNING) or (service_status != service_log_meta.service_status):
             service_log_meta.service_status = service_status
 
-            if service.deployment_step == DeploymentStep.MODEL_BUILD:
+            if service.deployment_step == deployment_step.DeploymentStep.MODEL_BUILD:
                 module_logger.info(
                     f"Image build service {service.display_service_name} is "
                     f"{service_log_meta.service_status.value}."
                 )
-            elif service.deployment_step == DeploymentStep.MODEL_INFERENCE:
+            elif service.deployment_step == deployment_step.DeploymentStep.MODEL_INFERENCE:
                 module_logger.info(
                     f"Inference service {service.display_service_name} is {service_log_meta.service_status.value}."
                 )
-            elif service.deployment_step == DeploymentStep.MODEL_LOGGING:
+            elif service.deployment_step == deployment_step.DeploymentStep.MODEL_LOGGING:
                 module_logger.info(
                     f"Model logger service {service.display_service_name} is "
                     f"{service_log_meta.service_status.value}."
@@ -622,7 +611,7 @@ class ServiceOperator:
         if service_status == service_sql.ServiceStatus.DONE:
             # check if model logger service is done
             # and transition the service log metadata to the model image build service
-            if service.deployment_step == DeploymentStep.MODEL_LOGGING:
+            if service.deployment_step == deployment_step.DeploymentStep.MODEL_LOGGING:
                 if model_build_service:
                     # building the inference image, transition to the model build service
                     service_log_meta.transition_service_log_metadata(
@@ -643,7 +632,7 @@ class ServiceOperator:
                     )
             # check if model build service is done
             # and transition the service log metadata to the model inference service
-            elif service.deployment_step == DeploymentStep.MODEL_BUILD:
+            elif service.deployment_step == deployment_step.DeploymentStep.MODEL_BUILD:
                 service_log_meta.transition_service_log_metadata(
                     model_inference_service,
                     f"Image build service {service.display_service_name} complete.",
@@ -651,7 +640,7 @@ class ServiceOperator:
                     is_model_logger_service_done=service_log_meta.is_model_logger_service_done,
                     operation_id=operation_id,
                 )
-            elif service.deployment_step == DeploymentStep.MODEL_INFERENCE:
+            elif service.deployment_step == deployment_step.DeploymentStep.MODEL_INFERENCE:
                 module_logger.info(f"Inference service {service.display_service_name} is deployed.")
             else:
                 module_logger.warning(f"Service {service.display_service_name} is done, but not transitioning.")
@@ -911,19 +900,6 @@ class ServiceOperator:
 
             time.sleep(2)  # Poll every 2 seconds
 
-    @staticmethod
-    def _get_service_id_from_deployment_step(query_id: str, deployment_step: DeploymentStep) -> str:
-        """Get the service ID through the server-side logic."""
-        uuid = query_id.replace("-", "")
-        big_int = int(uuid, 16)
-        md5_hash = hashlib.md5(str(big_int).encode()).hexdigest()
-        identifier = md5_hash[:8]
-        service_name_prefix = deployment_step.service_name_prefix
-        if service_name_prefix is None:
-            # raise an exception if the service name prefix is None
-            raise ValueError(f"Service name prefix is {service_name_prefix} for deployment step {deployment_step}.")
-        return (service_name_prefix + identifier).upper()
-
     def _check_if_service_exists(
         self,
         database_name: Optional[sql_identifier.SqlIdentifier],
@@ -966,6 +942,8 @@ class ServiceOperator:
         image_repo_name: Optional[str],
         input_stage_location: str,
         input_file_pattern: str,
+        column_handling: Optional[str],
+        params: Optional[str],
         output_stage_location: str,
         completion_filename: str,
         force_rebuild: bool,
@@ -976,7 +954,7 @@ class ServiceOperator:
         gpu_requests: Optional[str],
         replicas: Optional[int],
         statement_params: Optional[dict[str, Any]] = None,
-    ) -> jobs.MLJob[Any]:
+    ) -> job.MLJob[Any]:
         database_name = self._database_name
         schema_name = self._schema_name
 
@@ -1002,6 +980,8 @@ class ServiceOperator:
             max_batch_rows=max_batch_rows,
             input_stage_location=input_stage_location,
             input_file_pattern=input_file_pattern,
+            column_handling=column_handling,
+            params=params,
             output_stage_location=output_stage_location,
             completion_filename=completion_filename,
             function_name=function_name,
@@ -1045,7 +1025,7 @@ class ServiceOperator:
         # Block until the async job is done
         async_job.result()
 
-        return jobs.MLJob(
+        return job.MLJob(
             id=sql_identifier.get_fully_qualified_name(job_database_name, job_schema_name, job_name),
             session=self._session,
         )

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

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+from snowflake.ml.model._client.service import model_deployment_spec_schema
+
+BaseModel.model_config["protected_namespaces"] = ()
+
+
+class ModelName(BaseModel):
+    model_name: str
+    version_name: str
+
+
+class ModelSpec(BaseModel):
+    name: ModelName
+    hf_model: Optional[model_deployment_spec_schema.HuggingFaceModel] = None
+    log_model_args: Optional[model_deployment_spec_schema.LogModelArgs] = None
+
+
+class ImportModelSpec(BaseModel):
+    compute_pool: str
+    models: list[ModelSpec]

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

@@ -195,6 +195,7 @@ class ModelDeploymentSpec:
 
     def add_job_spec(
         self,
+        *,
         job_name: sql_identifier.SqlIdentifier,
         inference_compute_pool_name: sql_identifier.SqlIdentifier,
         function_name: str,
@@ -202,6 +203,8 @@ class ModelDeploymentSpec:
         output_stage_location: str,
         completion_filename: str,
         input_file_pattern: str,
+        column_handling: Optional[str] = None,
+        params: Optional[str] = None,
         warehouse: sql_identifier.SqlIdentifier,
         job_database_name: Optional[sql_identifier.SqlIdentifier] = None,
         job_schema_name: Optional[sql_identifier.SqlIdentifier] = None,
@@ -217,14 +220,16 @@ class ModelDeploymentSpec:
         Args:
             job_name: Name of the job.
             inference_compute_pool_name: Compute pool for inference.
-            warehouse: Warehouse for the job.
             function_name: Function name.
             input_stage_location: Stage location for input data.
             output_stage_location: Stage location for output data.
+            completion_filename: Name of completion file (default: "completion.txt").
+            input_file_pattern: Pattern for input files (optional).
+            column_handling: Column handling mode for input data.
+            params: Additional parameters for the job.
+            warehouse: Warehouse for the job.
             job_database_name: Database name for the job.
             job_schema_name: Schema name for the job.
-            input_file_pattern: Pattern for input files (optional).
-            completion_filename: Name of completion file (default: "completion.txt").
             cpu: CPU requirement.
             memory: Memory requirement.
             gpu: GPU requirement.
@@ -259,7 +264,10 @@ class ModelDeploymentSpec:
             warehouse=warehouse.identifier() if warehouse else None,
             function_name=function_name,
             input=model_deployment_spec_schema.Input(
-                input_stage_location=input_stage_location, input_file_pattern=input_file_pattern
+                input_stage_location=input_stage_location,
+                input_file_pattern=input_file_pattern,
+                column_handling=column_handling,
+                params=params,
             ),
             output=model_deployment_spec_schema.Output(
                 output_stage_location=output_stage_location,

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

@@ -39,6 +39,8 @@ class Service(BaseModel):
 class Input(BaseModel):
     input_stage_location: str
     input_file_pattern: str
+    column_handling: Optional[str] = None
+    params: Optional[str] = None
 
 
 class Output(BaseModel):
@@ -74,6 +76,7 @@ class HuggingFaceModel(BaseModel):
     task: Optional[str] = None
     tokenizer: Optional[str] = None
     token: Optional[str] = None
+    token_secret_object: Optional[str] = None
     trust_remote_code: Optional[bool] = False
     revision: Optional[str] = None
     hf_model_kwargs: Optional[str] = "{}"

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

@@ -22,6 +22,14 @@ def _normalize_url_for_sql(url: str) -> str:
     return f"'{url}'"
 
 
+def _format_param_value(value: Any) -> str:
+    if isinstance(value, str):
+        return f"'{snowpark_utils.escape_single_quotes(value)}'"  # type: ignore[no-untyped-call]
+    elif value is None:
+        return "NULL"
+    return str(value)
+
+
 class ModelVersionSQLClient(_base._BaseSQLClient):
     FUNCTION_NAME_COL_NAME = "name"
     FUNCTION_RETURN_TYPE_COL_NAME = "return_type"
@@ -354,6 +362,7 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
         input_args: list[sql_identifier.SqlIdentifier],
         returns: list[tuple[str, spt.DataType, sql_identifier.SqlIdentifier]],
         statement_params: Optional[dict[str, Any]] = None,
+        params: Optional[list[tuple[sql_identifier.SqlIdentifier, Any]]] = None,
     ) -> dataframe.DataFrame:
         with_statements = []
         if len(input_df.queries["queries"]) == 1 and len(input_df.queries["post_actions"]) == 0:
@@ -392,10 +401,17 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
 
         args_sql = ", ".join(args_sql_list)
 
-        wide_input = len(input_args) > constants.SNOWPARK_UDF_INPUT_COL_LIMIT
+        if params:
+            param_sql = ", ".join(_format_param_value(val) for _, val in params)
+            args_sql = f"{args_sql}, {param_sql}" if args_sql else param_sql
+
+        total_args = len(input_args) + (len(params) if params else 0)
+        wide_input = total_args > constants.SNOWPARK_UDF_INPUT_COL_LIMIT
         if wide_input:
-            input_args_sql = ", ".join(f"'{arg}', {arg.identifier()}" for arg in input_args)
-            args_sql = f"object_construct_keep_null({input_args_sql})"
+            parts = [f"'{arg}', {arg.identifier()}" for arg in input_args]
+            if params:
+                parts.extend(f"'{name}', {_format_param_value(val)}" for name, val in params)
+            args_sql = f"object_construct_keep_null({', '.join(parts)})"
 
         sql = textwrap.dedent(
             f"""WITH {','.join(with_statements)}
@@ -439,6 +455,7 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
         statement_params: Optional[dict[str, Any]] = None,
         is_partitioned: bool = True,
         explain_case_sensitive: bool = False,
+        params: Optional[list[tuple[sql_identifier.SqlIdentifier, Any]]] = None,
     ) -> dataframe.DataFrame:
         with_statements = []
         if len(input_df.queries["queries"]) == 1 and len(input_df.queries["post_actions"]) == 0:
@@ -477,10 +494,17 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
 
         args_sql = ", ".join(args_sql_list)
 
-        wide_input = len(input_args) > constants.SNOWPARK_UDF_INPUT_COL_LIMIT
+        if params:
+            param_sql = ", ".join(_format_param_value(val) for _, val in params)
+            args_sql = f"{args_sql}, {param_sql}" if args_sql else param_sql
+
+        total_args = len(input_args) + (len(params) if params else 0)
+        wide_input = total_args > constants.SNOWPARK_UDF_INPUT_COL_LIMIT
         if wide_input:
-            input_args_sql = ", ".join(f"'{arg}', {arg.identifier()}" for arg in input_args)
-            args_sql = f"object_construct_keep_null({input_args_sql})"
+            parts = [f"'{arg}', {arg.identifier()}" for arg in input_args]
+            if params:
+                parts.extend(f"'{name}', {_format_param_value(val)}" for name, val in params)
+            args_sql = f"object_construct_keep_null({', '.join(parts)})"
 
         sql = textwrap.dedent(
             f"""WITH {','.join(with_statements)}

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

@@ -3,7 +3,9 @@ import dataclasses
 import enum
 import logging
 import textwrap
-from typing import Any, Generator, Optional
+from typing import Any, Generator, Optional, cast
+
+import yaml
 
 from snowflake import snowpark
 from snowflake.ml._internal.utils import (
@@ -18,6 +20,15 @@ from snowflake.snowpark._internal import utils as snowpark_utils
 
 logger = logging.getLogger(__name__)
 
+
+def _format_param_value(value: Any) -> str:
+    if isinstance(value, str):
+        return f"'{snowpark_utils.escape_single_quotes(value)}'"  # type: ignore[no-untyped-call]
+    elif value is None:
+        return "NULL"
+    return str(value)
+
+
 # Using this token instead of '?' to avoid escaping issues
 # After quotes are escaped, we replace this token with '|| ? ||'
 QMARK_RESERVED_TOKEN = "<QMARK_RESERVED_TOKEN>"
@@ -68,6 +79,7 @@ class ServiceStatusInfo:
 
 class ServiceSQLClient(_base._BaseSQLClient):
     MODEL_INFERENCE_SERVICE_ENDPOINT_NAME_COL_NAME = "name"
+    MODEL_INFERENCE_SERVICE_ENDPOINT_PORT_COL_NAME = "port"
     MODEL_INFERENCE_SERVICE_ENDPOINT_INGRESS_URL_COL_NAME = "ingress_url"
     MODEL_INFERENCE_SERVICE_ENDPOINT_PRIVATELINK_INGRESS_URL_COL_NAME = "privatelink_ingress_url"
     SERVICE_STATUS = "service_status"
@@ -75,6 +87,14 @@ class ServiceSQLClient(_base._BaseSQLClient):
     INSTANCE_STATUS = "instance_status"
     CONTAINER_STATUS = "status"
     MESSAGE = "message"
+    DESC_SERVICE_INTERNAL_DNS_COL_NAME = "dns_name"
+    DESC_SERVICE_SPEC_COL_NAME = "spec"
+    DESC_SERVICE_CONTAINERS_SPEC_NAME = "containers"
+    DESC_SERVICE_NAME_SPEC_NAME = "name"
+    DESC_SERVICE_PROXY_SPEC_ENV_NAME = "env"
+    PROXY_CONTAINER_NAME = "proxy"
+    MODEL_INFERENCE_AUTOCAPTURE_ENV_NAME = "SPCS_MODEL_INFERENCE_SERVER__AUTOCAPTURE_ENABLED"
+    FEATURE_MODEL_INFERENCE_AUTOCAPTURE = "FEATURE_MODEL_INFERENCE_AUTOCAPTURE"
 
     @contextlib.contextmanager
     def _qmark_paramstyle(self) -> Generator[None, None, None]:
@@ -129,6 +149,7 @@ class ServiceSQLClient(_base._BaseSQLClient):
         input_args: list[sql_identifier.SqlIdentifier],
         returns: list[tuple[str, spt.DataType, sql_identifier.SqlIdentifier]],
         statement_params: Optional[dict[str, Any]] = None,
+        params: Optional[list[tuple[sql_identifier.SqlIdentifier, Any]]] = None,
     ) -> dataframe.DataFrame:
         with_statements = []
         actual_database_name = database_name or self._database_name
@@ -159,10 +180,17 @@ class ServiceSQLClient(_base._BaseSQLClient):
             args_sql_list.append(input_arg_value)
         args_sql = ", ".join(args_sql_list)
 
-        wide_input = len(input_args) > constants.SNOWPARK_UDF_INPUT_COL_LIMIT
+        if params:
+            param_sql = ", ".join(_format_param_value(val) for _, val in params)
+            args_sql = f"{args_sql}, {param_sql}" if args_sql else param_sql
+
+        total_args = len(input_args) + (len(params) if params else 0)
+        wide_input = total_args > constants.SNOWPARK_UDF_INPUT_COL_LIMIT
         if wide_input:
-            input_args_sql = ", ".join(f"'{arg}', {arg.identifier()}" for arg in input_args)
-            args_sql = f"object_construct_keep_null({input_args_sql})"
+            parts = [f"'{arg}', {arg.identifier()}" for arg in input_args]
+            if params:
+                parts.extend(f"'{name}', {_format_param_value(val)}" for name, val in params)
+            args_sql = f"object_construct_keep_null({', '.join(parts)})"
 
         fully_qualified_service_name = self.fully_qualified_object_name(
             actual_database_name, actual_schema_name, service_name
@@ -233,7 +261,15 @@ class ServiceSQLClient(_base._BaseSQLClient):
     ) -> 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)
+        rows = (
+            query_result_checker.SqlResultValidator(self._session, query, statement_params=statement_params)
+            .has_column(ServiceSQLClient.INSTANCE_STATUS)
+            .has_column(ServiceSQLClient.CONTAINER_STATUS)
+            .has_column(ServiceSQLClient.SERVICE_STATUS)
+            .has_column(ServiceSQLClient.INSTANCE_ID)
+            .has_column(ServiceSQLClient.MESSAGE)
+            .validate()
+        )
         statuses = []
         for r in rows:
             instance_status, container_status = None, None
@@ -252,6 +288,58 @@ class ServiceSQLClient(_base._BaseSQLClient):
             )
         return statuses
 
+    def describe_service(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        service_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[dict[str, Any]] = None,
+    ) -> row.Row:
+        fully_qualified_object_name = self.fully_qualified_object_name(database_name, schema_name, service_name)
+        query = f"DESCRIBE SERVICE {fully_qualified_object_name}"
+        rows = (
+            query_result_checker.SqlResultValidator(self._session, query, statement_params=statement_params)
+            .has_dimensions(expected_rows=1)
+            .has_column(ServiceSQLClient.DESC_SERVICE_INTERNAL_DNS_COL_NAME)
+            .validate()
+        )
+        return rows[0]
+
+    def get_proxy_container_autocapture(self, row: row.Row) -> bool:
+        """Extract whether service has autocapture enabled from proxy container spec.
+
+        Args:
+            row: A row.Row object from DESCRIBE SERVICE containing the service YAML spec.
+
+        Returns:
+            True if autocapture is enabled in proxy spec
+            False if disabled or not set in proxy spec
+            False if service doesn't have proxy container
+        """
+        try:
+            spec_yaml = row[ServiceSQLClient.DESC_SERVICE_SPEC_COL_NAME]
+            if spec_yaml is None:
+                return False
+            spec_raw = yaml.safe_load(spec_yaml)
+            if spec_raw is None:
+                return False
+            spec = cast(dict[str, Any], spec_raw)
+
+            proxy_container_spec = next(
+                container
+                for container in spec[ServiceSQLClient.DESC_SERVICE_SPEC_COL_NAME][
+                    ServiceSQLClient.DESC_SERVICE_CONTAINERS_SPEC_NAME
+                ]
+                if container[ServiceSQLClient.DESC_SERVICE_NAME_SPEC_NAME] == ServiceSQLClient.PROXY_CONTAINER_NAME
+            )
+            env = proxy_container_spec.get(ServiceSQLClient.DESC_SERVICE_PROXY_SPEC_ENV_NAME, {})
+            autocapture_enabled = env.get(ServiceSQLClient.MODEL_INFERENCE_AUTOCAPTURE_ENV_NAME, "false")
+            return str(autocapture_enabled).lower() == "true"
+
+        except StopIteration:
+            return False
+
     def drop_service(
         self,
         *,
@@ -282,6 +370,7 @@ class ServiceSQLClient(_base._BaseSQLClient):
                 statement_params=statement_params,
             )
             .has_column(ServiceSQLClient.MODEL_INFERENCE_SERVICE_ENDPOINT_NAME_COL_NAME, allow_empty=True)
+            .has_column(ServiceSQLClient.MODEL_INFERENCE_SERVICE_ENDPOINT_PORT_COL_NAME, allow_empty=True)
             .has_column(ServiceSQLClient.MODEL_INFERENCE_SERVICE_ENDPOINT_INGRESS_URL_COL_NAME, allow_empty=True)
         )
 

snowflake/ml/model/_model_composer/model_composer.py

@@ -131,7 +131,7 @@ class ModelComposer:
         python_version: Optional[str] = None,
         user_files: Optional[dict[str, list[str]]] = None,
         ext_modules: Optional[list[ModuleType]] = None,
-        code_paths: Optional[list[str]] = None,
+        code_paths: Optional[list[model_types.CodePathLike]] = None,
         task: model_types.Task = model_types.Task.UNKNOWN,
         experiment_info: Optional["ExperimentInfo"] = None,
         options: Optional[model_types.ModelSaveOption] = None,

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

@@ -39,6 +39,10 @@ class ModelMethodSignatureFieldWithName(ModelMethodSignatureField):
     name: Required[str]
 
 
+class ModelMethodSignatureFieldWithNameAndDefault(ModelMethodSignatureFieldWithName):
+    default: Required[Any]
+
+
 class ModelFunctionMethodDict(TypedDict):
     name: Required[str]
     runtime: Required[str]
@@ -46,6 +50,7 @@ class ModelFunctionMethodDict(TypedDict):
     handler: Required[str]
     inputs: Required[list[ModelMethodSignatureFieldWithName]]
     outputs: Required[Union[list[ModelMethodSignatureField], list[ModelMethodSignatureFieldWithName]]]
+    params: NotRequired[list[ModelMethodSignatureFieldWithNameAndDefault]]
     volatility: NotRequired[str]