snowflake-ml-python 1.24.0__tar.gz → 1.25.1__tar.gz

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Release History
 
+## 1.25.1
+
+### Bug Fixes
+
+* ML Job: Reverted changes related to the introduction of ML Job Definitions.
+
+## 1.25.0
+
+### New Features
+
+* ML Job: Added support for creating ML job definitions and launching jobs with different
+  arguments without re-uploading payloads.
+
+* Inference Autocapture (PuPr): The `create_service` API will now accept `autocapture` as a new argument to indicate
+  whether inference data will be captured.
+
+* Model serving: Introduced the `min_instances` field in the `mv.create_service()` and
+  `HuggingFacePipelineModel.log_model_and_create_service()` APIs (defaulting to 0). The service now launches
+  with the `min_instances` and automatically scales between `min_instances` and `max_instances` based on
+  traffic and hardware utilization. When `min_instances` is set to 0, the service will automatically suspend
+  if no traffic is detected for a period of time.
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Inference Autocapture (PuPr): `list_services()` now shows `autocapture_enabled` column to indicate if model
+  service has autocapture enabled.
+
+* Model serving: The `mv.create_service()` and `HuggingFacePipelineModel.log_model_and_create_service()` APIs now
+  include a `min_instances` field (defaulting to 0). When these APIs are called without specifying `min_instances`,
+  the system will now launch the service with 1 instance and enable auto scaling. This replaces the previous behavior,
+  where `min_instances` was automatically set to match `max_instances`, resulting in the immediate launch of the
+  maximum number of instances.
+
+### Deprecations
+
 ## 1.24.0
 
 ### New Features
@@ -103,7 +140,15 @@ x_df = pd.DataFrame.from_records(
     [
         {
             "messages": [
-                {"role": "system", "content": "Complete the sentence."},
+                {
+                  "role": "system",
+                  "content": [
+                        {
+                            "type": "text",
+                            "text": "Complete the sentence."
+                        },
+                  ]
+                },
                 {
                     "role": "user",
                     "content": [

{snowflake_ml_python-1.24.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.25.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.24.0
+Version: 1.25.1
 Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
 Author-email: "Snowflake, Inc" <support@snowflake.com>
 License: 
@@ -417,6 +417,43 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.25.1
+
+### Bug Fixes
+
+* ML Job: Reverted changes related to the introduction of ML Job Definitions.
+
+## 1.25.0
+
+### New Features
+
+* ML Job: Added support for creating ML job definitions and launching jobs with different
+  arguments without re-uploading payloads.
+
+* Inference Autocapture (PuPr): The `create_service` API will now accept `autocapture` as a new argument to indicate
+  whether inference data will be captured.
+
+* Model serving: Introduced the `min_instances` field in the `mv.create_service()` and
+  `HuggingFacePipelineModel.log_model_and_create_service()` APIs (defaulting to 0). The service now launches
+  with the `min_instances` and automatically scales between `min_instances` and `max_instances` based on
+  traffic and hardware utilization. When `min_instances` is set to 0, the service will automatically suspend
+  if no traffic is detected for a period of time.
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Inference Autocapture (PuPr): `list_services()` now shows `autocapture_enabled` column to indicate if model
+  service has autocapture enabled.
+
+* Model serving: The `mv.create_service()` and `HuggingFacePipelineModel.log_model_and_create_service()` APIs now
+  include a `min_instances` field (defaulting to 0). When these APIs are called without specifying `min_instances`,
+  the system will now launch the service with 1 instance and enable auto scaling. This replaces the previous behavior,
+  where `min_instances` was automatically set to match `max_instances`, resulting in the immediate launch of the
+  maximum number of instances.
+
+### Deprecations
+
 ## 1.24.0
 
 ### New Features
@@ -520,7 +557,15 @@ x_df = pd.DataFrame.from_records(
     [
         {
             "messages": [
-                {"role": "system", "content": "Complete the sentence."},
+                {
+                  "role": "system",
+                  "content": [
+                        {
+                            "type": "text",
+                            "text": "Complete the sentence."
+                        },
+                  ]
+                },
                 {
                     "role": "user",
                     "content": [

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/data/_internal/arrow_ingestor.py

@@ -73,15 +73,19 @@ class ArrowIngestor(data_ingestor.DataIngestor, mixins.SerializableSessionMixin)
         self._schema: Optional[pa.Schema] = None
 
     @classmethod
-    def from_sources(cls, session: snowpark.Session, sources: Sequence[data_source.DataSource]) -> "ArrowIngestor":
+    def from_sources(
+        cls, session: snowpark.Session, sources: Sequence[data_source.DataSource], **kwargs: Any
+    ) -> "ArrowIngestor":
         if session is None:
             raise ValueError("Session is required")
+        # Skipping kwargs until needed to avoid impact other workflows.
         return cls(session, sources)
 
     @classmethod
     def from_ray_dataset(
         cls,
         ray_ds: "ray.data.Dataset",
+        **kwargs: Any,
     ) -> "ArrowIngestor":
         raise NotImplementedError
 

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/data/data_connector.py

@@ -94,7 +94,7 @@ class DataConnector:
         **kwargs: Any,
     ) -> DataConnectorType:
         ingestor_class = ingestor_class or cls.DEFAULT_INGESTOR_CLASS
-        ray_ingestor = ingestor_class.from_ray_dataset(ray_ds=ray_ds)
+        ray_ingestor = ingestor_class.from_ray_dataset(ray_ds=ray_ds, **kwargs)
         return cls(ray_ingestor, **kwargs)
 
     @classmethod
@@ -111,7 +111,7 @@ class DataConnector:
         **kwargs: Any,
     ) -> DataConnectorType:
         ingestor_class = ingestor_class or cls.DEFAULT_INGESTOR_CLASS
-        ingestor = ingestor_class.from_sources(session, sources)
+        ingestor = ingestor_class.from_sources(session, sources, **kwargs)
         return cls(ingestor, **kwargs)
 
     @property

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/data/data_ingestor.py

@@ -16,7 +16,7 @@ DataIngestorType = TypeVar("DataIngestorType", bound="DataIngestor")
 class DataIngestor(Protocol):
     @classmethod
     def from_sources(
-        cls: type[DataIngestorType], session: snowpark.Session, sources: Sequence[data_source.DataSource]
+        cls: type[DataIngestorType], session: snowpark.Session, sources: Sequence[data_source.DataSource], **kwargs: Any
     ) -> DataIngestorType:
         raise NotImplementedError
 
@@ -24,6 +24,7 @@ class DataIngestor(Protocol):
     def from_ray_dataset(
         cls: type[DataIngestorType],
         ray_ds: "ray.data.Dataset",
+        **kwargs: Any,
     ) -> DataIngestorType:
         raise NotImplementedError
 

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/experiment/_experiment_info.py

@@ -3,7 +3,7 @@ import functools
 import types
 from typing import Callable, Optional
 
-from snowflake.ml import model
+from snowflake.ml.model._client.model import model_version_impl
 from snowflake.ml.registry._manager import model_manager
 
 
@@ -23,7 +23,7 @@ class ExperimentInfoPatcher:
     """
 
     # Store original method at class definition time to avoid recursive patching
-    _original_log_model: Callable[..., model.ModelVersion] = model_manager.ModelManager.log_model
+    _original_log_model: Callable[..., model_version_impl.ModelVersion] = model_manager.ModelManager.log_model
 
     # Stack of active experiment_info contexts for nested experiment support
     _experiment_info_stack: list[ExperimentInfo] = []
@@ -36,7 +36,7 @@ class ExperimentInfoPatcher:
         if not ExperimentInfoPatcher._experiment_info_stack:
 
             @functools.wraps(ExperimentInfoPatcher._original_log_model)
-            def patched(*args, **kwargs) -> model.ModelVersion:  # type: ignore[no-untyped-def]
+            def patched(*args, **kwargs) -> model_version_impl.ModelVersion:  # type: ignore[no-untyped-def]
                 # Use the most recent (top of stack) experiment_info for nested contexts
                 current_experiment_info = ExperimentInfoPatcher._experiment_info_stack[-1]
                 return ExperimentInfoPatcher._original_log_model(

snowflake_ml_python-1.25.1/snowflake/ml/jobs/_utils/feature_flags.py

@@ -0,0 +1,133 @@
+import os
+from typing import Callable, Optional, Union
+
+from snowflake.ml._internal.utils.snowflake_env import SnowflakeCloudType
+from snowflake.snowpark import context as sp_context
+
+# Default value type: can be a bool or a callable that returns a bool
+DefaultValue = Union[bool, Callable[[], bool]]
+
+
+def parse_bool_env_value(value: Optional[str], default: bool = False) -> bool:
+    """Parse a boolean value from an environment variable string.
+
+    Args:
+        value: The environment variable value to parse (may be None).
+        default: The default value to return if the value is None or unrecognized.
+
+    Returns:
+        True if the value is a truthy string (true, 1, yes, on - case insensitive),
+        False if the value is a falsy string (false, 0, no, off - case insensitive),
+        or the default value if the value is None or unrecognized.
+    """
+    if value is None:
+        return default
+
+    normalized_value = value.strip().lower()
+    if normalized_value in ("true", "1", "yes", "on"):
+        return True
+    elif normalized_value in ("false", "0", "no", "off"):
+        return False
+    else:
+        # For unrecognized values, return the default
+        return default
+
+
+def _enabled_in_clouds(*clouds: SnowflakeCloudType) -> Callable[[], bool]:
+    """Create a callable that checks if the current environment is in any of the specified clouds.
+
+    This factory function returns a callable that can be used as a dynamic default
+    for feature flags. The returned callable will check if the current Snowflake
+    session is connected to a region in any of the specified cloud providers.
+
+    Args:
+        *clouds: One or more SnowflakeCloudType values to check against.
+
+    Returns:
+        A callable that returns True if running in any of the specified clouds,
+        False otherwise (including when no session is available).
+
+    Example:
+        >>> # Enable feature only in GCP
+        >>> default=_enabled_in_clouds(SnowflakeCloudType.GCP)
+        >>>
+        >>> # Enable feature in both GCP and Azure
+        >>> default=_enabled_in_clouds(SnowflakeCloudType.GCP, SnowflakeCloudType.AZURE)
+    """
+    cloud_set = frozenset(clouds)
+
+    def check() -> bool:
+        try:
+            from snowflake.ml._internal.utils.snowflake_env import get_current_cloud
+
+            session = sp_context.get_active_session()
+            current_cloud = get_current_cloud(session, default=SnowflakeCloudType.AWS)
+            return current_cloud in cloud_set
+        except Exception:
+            # If we can't determine the cloud (no session, SQL error, etc.),
+            # default to False for safety
+            return False
+
+    return check
+
+
+class _FeatureFlag:
+    """A feature flag backed by an environment variable with a configurable default.
+
+    The default value can be a constant boolean or a callable that dynamically
+    determines the default based on runtime context (e.g., cloud provider).
+    """
+
+    def __init__(self, env_var: str, default: DefaultValue = False) -> None:
+        """Initialize a feature flag.
+
+        Args:
+            env_var: The environment variable name that controls this flag.
+            default: The default value when the env var is not set. Can be:
+                - A boolean constant (True/False)
+                - A callable that returns a boolean (evaluated at check time)
+        """
+        self._env_var = env_var
+        self._default = default
+
+    @property
+    def value(self) -> str:
+        """Return the environment variable name (for compatibility with Enum-style access)."""
+        return self._env_var
+
+    def _get_default(self) -> bool:
+        """Get the default value, calling it if it's a callable."""
+        if callable(self._default):
+            return self._default()
+        return self._default
+
+    def is_enabled(self) -> bool:
+        """Check if the feature flag is enabled.
+
+        First checks the environment variable. If not set or unrecognized,
+        falls back to the configured default value.
+
+        Returns:
+            True if the feature is enabled, False otherwise.
+        """
+        env_value = os.getenv(self._env_var)
+        if env_value is not None:
+            # Environment variable is set, parse it
+            result = parse_bool_env_value(env_value, default=self._get_default())
+            return result
+        else:
+            # Environment variable not set, use the default
+            return self._get_default()
+
+    def __str__(self) -> str:
+        return self._env_var
+
+
+class FeatureFlags:
+    """Collection of feature flags for ML Jobs."""
+
+    ENABLE_RUNTIME_VERSIONS = _FeatureFlag("MLRS_ENABLE_RUNTIME_VERSIONS", default=True)
+    ENABLE_STAGE_MOUNT_V2 = _FeatureFlag(
+        "MLRS_ENABLE_STAGE_MOUNT_V2",
+        default=_enabled_in_clouds(SnowflakeCloudType.GCP),
+    )

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/jobs/job_definition.py

@@ -49,8 +49,14 @@ class MLJobDefinition(Generic[_Args, _ReturnValue], SerializableSessionMixin):
         self.spec_options = spec_options
         self.compute_pool = compute_pool
         self.session = session or sp_context.get_active_session()
-        self.database = database or self.session.get_current_database()
-        self.schema = schema or self.session.get_current_schema()
+        resolved_database = database or self.session.get_current_database()
+        resolved_schema = schema or self.session.get_current_schema()
+        if resolved_database is None:
+            raise ValueError("Database must be specified either in the session context or as a parameter.")
+        if resolved_schema is None:
+            raise ValueError("Schema must be specified either in the session context or as a parameter.")
+        self.database = identifier.resolve_identifier(resolved_database)
+        self.schema = identifier.resolve_identifier(resolved_schema)
         self.job_definition_id = identifier.get_schema_level_object_identifier(self.database, self.schema, name)
         self.entrypoint_args = entrypoint_args
 
@@ -190,7 +196,7 @@ class MLJobDefinition(Generic[_Args, _ReturnValue], SerializableSessionMixin):
                 )
             raise
 
-        if runtime_environment is None and feature_flags.FeatureFlags.ENABLE_RUNTIME_VERSIONS.is_enabled(default=True):
+        if runtime_environment is None and feature_flags.FeatureFlags.ENABLE_RUNTIME_VERSIONS.is_enabled():
             # Pass a JSON object for runtime versions so it serializes as nested JSON in options
             runtime_environment = json.dumps({"pythonVersion": f"{sys.version_info.major}.{sys.version_info.minor}"})
 
@@ -204,7 +210,7 @@ class MLJobDefinition(Generic[_Args, _ReturnValue], SerializableSessionMixin):
             enable_metrics=enable_metrics,
             spec_overrides=spec_overrides,
             runtime=runtime_environment if runtime_environment else None,
-            enable_stage_mount_v2=feature_flags.FeatureFlags.ENABLE_STAGE_MOUNT_V2.is_enabled(default=True),
+            enable_stage_mount_v2=feature_flags.FeatureFlags.ENABLE_STAGE_MOUNT_V2.is_enabled(),
         )
 
         job_options = types.JobOptions(

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/model/_client/model/model_version_impl.py

@@ -33,6 +33,12 @@ _BATCH_INFERENCE_TEMPORARY_FOLDER = "_temporary"
 VLLM_SUPPORTED_TASKS = [
     "text-generation",
     "image-text-to-text",
+    "video-text-to-text",
+    "audio-text-to-text",
+]
+VALID_OPENAI_SIGNATURES = [
+    openai_signatures.OPENAI_CHAT_SIGNATURE,
+    openai_signatures.OPENAI_CHAT_SIGNATURE_WITH_CONTENT_FORMAT_STRING,
 ]
 
 
@@ -1140,16 +1146,11 @@ class ModelVersion(lineage_node.LineageNode):
             func_name: core.ModelSignature.from_dict(sig_dict) for func_name, sig_dict in signatures_dict.items()
         }
 
-        if deserialized_signatures not in [
-            openai_signatures.OPENAI_CHAT_SIGNATURE,
-            openai_signatures.OPENAI_CHAT_SIGNATURE_WITH_CONTENT_FORMAT_STRING,
-        ]:
+        if deserialized_signatures not in VALID_OPENAI_SIGNATURES:
             raise ValueError(
-                "Inference engine requires the model to be logged with openai_signatures.OPENAI_CHAT_SIGNATURE or "
-                "openai_signatures.OPENAI_CHAT_SIGNATURE_WITH_CONTENT_FORMAT_STRING. "
+                "Inference engine requires the model to be logged with one of the following signatures: "
+                f"{VALID_OPENAI_SIGNATURES}. Please log the model again with one of these supported signatures."
                 f"Found signatures: {signatures_dict}. "
-                "Please log the model again with: signatures=openai_signatures.OPENAI_CHAT_SIGNATURE or "
-                "signatures=openai_signatures.OPENAI_CHAT_SIGNATURE_WITH_CONTENT_FORMAT_STRING"
             )
 
     @overload
@@ -1161,6 +1162,7 @@ class ModelVersion(lineage_node.LineageNode):
         service_compute_pool: str,
         image_repo: Optional[str] = None,
         ingress_enabled: bool = False,
+        min_instances: int = 0,
         max_instances: int = 1,
         cpu_requests: Optional[str] = None,
         memory_requests: Optional[str] = None,
@@ -1187,8 +1189,10 @@ class ModelVersion(lineage_node.LineageNode):
                 will be used.
             ingress_enabled: If true, creates an service endpoint associated with the service. User must have
                 BIND SERVICE ENDPOINT privilege on the account.
-            max_instances: The maximum number of inference service instances to run. The same value it set to
-                MIN_INSTANCES property of the service.
+            min_instances: The minimum number of instances for the inference service. The service will automatically
+                scale between min_instances and max_instances based on traffic and hardware utilization. If set to
+                0 (default), the service will automatically suspend after a period of inactivity.
+            max_instances: The maximum number of instances for the inference service.
             cpu_requests: The cpu limit for CPU based inference. Can be an integer, fractional or string values. If
                 None, we attempt to utilize all the vCPU of the node.
             memory_requests: The memory limit with for CPU based inference. Can be an integer or a fractional value, but
@@ -1224,6 +1228,7 @@ class ModelVersion(lineage_node.LineageNode):
         service_compute_pool: str,
         image_repo: Optional[str] = None,
         ingress_enabled: bool = False,
+        min_instances: int = 0,
         max_instances: int = 1,
         cpu_requests: Optional[str] = None,
         memory_requests: Optional[str] = None,
@@ -1250,8 +1255,10 @@ class ModelVersion(lineage_node.LineageNode):
                 will be used.
             ingress_enabled: If true, creates an service endpoint associated with the service. User must have
                 BIND SERVICE ENDPOINT privilege on the account.
-            max_instances: The maximum number of inference service instances to run. The same value it set to
-                MIN_INSTANCES property of the service.
+            min_instances: The minimum number of instances for the inference service. The service will automatically
+                scale between min_instances and max_instances based on traffic and hardware utilization. If set to
+                0 (default), the service will automatically suspend after a period of inactivity.
+            max_instances: The maximum number of instances for the inference service.
             cpu_requests: The cpu limit for CPU based inference. Can be an integer, fractional or string values. If
                 None, we attempt to utilize all the vCPU of the node.
             memory_requests: The memory limit with for CPU based inference. Can be an integer or a fractional value, but
@@ -1301,6 +1308,7 @@ class ModelVersion(lineage_node.LineageNode):
         service_compute_pool: str,
         image_repo: Optional[str] = None,
         ingress_enabled: bool = False,
+        min_instances: int = 0,
         max_instances: int = 1,
         cpu_requests: Optional[str] = None,
         memory_requests: Optional[str] = None,
@@ -1328,8 +1336,10 @@ class ModelVersion(lineage_node.LineageNode):
                 will be used.
             ingress_enabled: If true, creates an service endpoint associated with the service. User must have
                 BIND SERVICE ENDPOINT privilege on the account.
-            max_instances: The maximum number of inference service instances to run. The same value it set to
-                MIN_INSTANCES property of the service.
+            min_instances: The minimum number of instances for the inference service. The service will automatically
+                scale between min_instances and max_instances based on traffic and hardware utilization. If set to
+                0 (default), the service will automatically suspend after a period of inactivity.
+            max_instances: The maximum number of instances for the inference service.
             cpu_requests: The cpu limit for CPU based inference. Can be an integer, fractional or string values. If
                 None, we attempt to utilize all the vCPU of the node.
             memory_requests: The memory limit with for CPU based inference. Can be an integer or a fractional value, but
@@ -1419,6 +1429,7 @@ class ModelVersion(lineage_node.LineageNode):
                     service_compute_pool_name=sql_identifier.SqlIdentifier(service_compute_pool),
                     image_repo_name=image_repo,
                     ingress_enabled=ingress_enabled,
+                    min_instances=min_instances,
                     max_instances=max_instances,
                     cpu_requests=cpu_requests,
                     memory_requests=memory_requests,

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/model/_client/ops/service_ops.py

@@ -175,6 +175,7 @@ class ServiceOperator:
         service_compute_pool_name: sql_identifier.SqlIdentifier,
         image_repo_name: Optional[str],
         ingress_enabled: bool,
+        min_instances: int,
         max_instances: int,
         cpu_requests: Optional[str],
         memory_requests: Optional[str],
@@ -241,6 +242,7 @@ class ServiceOperator:
             service_name=service_name,
             inference_compute_pool_name=service_compute_pool_name,
             ingress_enabled=ingress_enabled,
+            min_instances=min_instances,
             max_instances=max_instances,
             cpu=cpu_requests,
             memory=memory_requests,
@@ -829,15 +831,13 @@ class ServiceOperator:
         service_seen_before = False
 
         while True:
-            # Check if async job has failed (but don't return on success - we need specific service status)
+            # Check if async job has completed
             if async_job.is_done():
                 try:
                     async_job.result()
-                    # Async job completed successfully, but we're waiting for a specific service status
-                    # This might mean the service completed and was cleaned up
-                    module_logger.debug(
-                        f"Async job completed but we're still waiting for {service_name} to reach {target_status.value}"
-                    )
+                    # Async job completed successfully - deployment is done
+                    module_logger.debug(f"Async job completed successfully, returning from wait for {service_name}")
+                    return
                 except Exception as e:
                     raise RuntimeError(f"Service deployment failed: {e}")
 

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/model/_client/service/model_deployment_spec.py

@@ -140,6 +140,7 @@ class ModelDeploymentSpec:
         service_database_name: Optional[sql_identifier.SqlIdentifier] = None,
         service_schema_name: Optional[sql_identifier.SqlIdentifier] = None,
         ingress_enabled: bool = True,
+        min_instances: int = 0,
         max_instances: int = 1,
         cpu: Optional[str] = None,
         memory: Optional[str] = None,
@@ -156,6 +157,7 @@ class ModelDeploymentSpec:
             service_database_name: Database name for the service.
             service_schema_name: Schema name for the service.
             ingress_enabled: Whether ingress is enabled.
+            min_instances: Minimum number of service instances.
             max_instances: Maximum number of service instances.
             cpu: CPU requirement.
             memory: Memory requirement.
@@ -187,6 +189,7 @@ class ModelDeploymentSpec:
             name=fq_service_name,
             compute_pool=inference_compute_pool_name.identifier(),
             ingress_enabled=ingress_enabled,
+            min_instances=min_instances,
             max_instances=max_instances,
             autocapture=autocapture,
             **self._inference_spec,

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/model/_client/service/model_deployment_spec_schema.py

@@ -26,6 +26,7 @@ class Service(BaseModel):
     name: str
     compute_pool: str
     ingress_enabled: bool
+    min_instances: int
     max_instances: int
     cpu: Optional[str] = None
     memory: Optional[str] = None

{snowflake_ml_python-1.24.0 → snowflake_ml_python-1.25.1}/snowflake/ml/model/models/huggingface_pipeline.py

@@ -105,6 +105,7 @@ class HuggingFacePipelineModel(huggingface.TransformersPipeline):
         image_repo: Optional[str] = None,
         image_build_compute_pool: Optional[str] = None,
         ingress_enabled: bool = False,
+        min_instances: int = 0,
         max_instances: int = 1,
         cpu_requests: Optional[str] = None,
         memory_requests: Optional[str] = None,
@@ -133,6 +134,7 @@ class HuggingFacePipelineModel(huggingface.TransformersPipeline):
             image_build_compute_pool: The name of the compute pool used to build the model inference image. It uses
             the service compute pool if None.
             ingress_enabled: Whether ingress is enabled. Defaults to False.
+            min_instances: Minimum number of instances. Defaults to 0.
             max_instances: Maximum number of instances. Defaults to 1.
             cpu_requests: CPU requests configuration. Defaults to None.
             memory_requests: Memory requests configuration. Defaults to None.
@@ -225,6 +227,7 @@ class HuggingFacePipelineModel(huggingface.TransformersPipeline):
                     service_compute_pool_name=sql_identifier.SqlIdentifier(service_compute_pool),
                     image_repo_name=image_repo,
                     ingress_enabled=ingress_enabled,
+                    min_instances=min_instances,
                     max_instances=max_instances,
                     cpu_requests=cpu_requests,
                     memory_requests=memory_requests,