snowflake-ml-python 1.25.0__tar.gz → 1.26.0__tar.gz

{snowflake_ml_python-1.25.0 → snowflake_ml_python-1.26.0}/CHANGELOG.md

@@ -1,5 +1,139 @@
 # Release History
 
+## 1.26.0
+
+### New Features
+
+* ML Job: Added support for creating `MLJobDefinition` (PrPr) and launching jobs with different
+  arguments without re-uploading payloads.
+
+```python
+# /path/to/repo/my_script.py
+
+def main(*args):
+    print("Hello world", *args)
+
+if __name__ == '__main__':
+    import sys
+    main(*sys.argv[1:])
+
+from snowflake.ml.jobs.job_definition import MLJobDefinition
+job_def = MLJobDefinition.register(
+  "/path/to/repo/my_script.py",
+  # If you register a source directory, provide the entrypoint file:
+  # entrypoint="/path/to/repo/my_script.py",
+  compute_pool= "test_comput_pool",
+  stage_name="payload_stage",
+)
+
+job1 = job_def()
+job2 = job_def(arg1="ML Job")
+
+
+from snowflake.ml import jobs
+@jobs.remote(compute_pool = "test_compute_pool", stage_name = "payload_stage")
+def test_job(arg1: str = "world") -> None:
+  print(f"hello {arg1}")
+
+# this is a job definition handle
+job_def_remote = test_job
+
+job1 = job_def_remote()
+job2 = job_def_remote(arg1="ML Job")
+
+
+```
+
+* Job-based Batch Inference (PuPr): `ModelVersion.run_batch` for job-based batch inference in Snowpark Container
+Services is now in public preview.
+
+```python
+from snowflake.ml.registry import Registry
+from snowflake.ml.model import OutputSpec
+
+registry = Registry(session)
+mv = registry.log_model( ... )
+
+job = mv.run_batch(
+    compute_pool = "SYSTEM_COMPUTE_POOL_GPU",
+    X=input_df,
+    output_spec=OutputSpec(stage_location="@my_db.my_schema.my_stage/output/"),
+)
+```
+
+* Registry: Added support for inference parameters via `ParamSpec` in model signatures. This allows you to define
+  constant parameters that can be passed at inference time without being part of the input data.
+
+```python
+import pandas as pd
+from snowflake.ml.model import custom_model, model_signature
+from snowflake.ml.registry import Registry
+
+# Define a custom model with inference parameters
+class MyModelWithParams(custom_model.CustomModel):
+    @custom_model.inference_api
+    def predict(
+        self,
+        input_df: pd.DataFrame,
+        *,
+        temperature: float = 1.0,  # keyword-only param with default
+    ) -> pd.DataFrame:
+        return pd.DataFrame({"output": input_df["feature"] * temperature})
+
+# Create sample data
+model = MyModelWithParams(custom_model.ModelContext())
+sample_input = pd.DataFrame({"feature": [1.0, 2.0, 3.0]})
+sample_output = model.predict(sample_input, temperature=1.0)
+
+# Define ParamSpec for the inference parameter
+params = [
+    model_signature.ParamSpec(
+        name="temperature",
+        dtype=model_signature.DataType.FLOAT,
+        default_value=1.0,
+    ),
+]
+
+# Infer signature with params
+sig = model_signature.infer_signature(
+    input_data=sample_input,
+    output_data=sample_output,
+    params=params,
+)
+
+# Log model with the signature
+registry = Registry(session)
+mv = registry.log_model(
+    model=model,
+    model_name="my_model_with_params",
+    version_name="v1",
+    signatures={"predict": sig},
+)
+
+# Run inference with custom parameter value
+result = mv.run(sample_input, function_name="predict", params={"temperature": 2.0})
+```
+
+* Feature Store: Added `auto_prefix` parameter and `with_name()` method to avoid column name collisions when
+  joining multiple feature views in dataset generation.
+
+* Feature Store: Added support for Dynamic Iceberg Tables as the backing storage for Feature Views.
+  Use `StorageConfig` with `StorageFormat.ICEBERG` to create Iceberg-backed Feature Views that store
+  data in open Apache Iceberg format on external cloud storage. A new `default_iceberg_external_volume`
+  parameter is available in `FeatureStore` to set a default external volume for Iceberg Feature Views.
+
+### Bug Fixes
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.25.1
+
+### Bug Fixes
+
+* ML Job: Reverted changes related to the introduction of ML Job Definitions.
+
 ## 1.25.0
 
 ### New Features

{snowflake_ml_python-1.25.0/snowflake_ml_python.egg-info → snowflake_ml_python-1.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.25.0
+Version: 1.26.0
 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,140 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.26.0
+
+### New Features
+
+* ML Job: Added support for creating `MLJobDefinition` (PrPr) and launching jobs with different
+  arguments without re-uploading payloads.
+
+```python
+# /path/to/repo/my_script.py
+
+def main(*args):
+    print("Hello world", *args)
+
+if __name__ == '__main__':
+    import sys
+    main(*sys.argv[1:])
+
+from snowflake.ml.jobs.job_definition import MLJobDefinition
+job_def = MLJobDefinition.register(
+  "/path/to/repo/my_script.py",
+  # If you register a source directory, provide the entrypoint file:
+  # entrypoint="/path/to/repo/my_script.py",
+  compute_pool= "test_comput_pool",
+  stage_name="payload_stage",
+)
+
+job1 = job_def()
+job2 = job_def(arg1="ML Job")
+
+
+from snowflake.ml import jobs
+@jobs.remote(compute_pool = "test_compute_pool", stage_name = "payload_stage")
+def test_job(arg1: str = "world") -> None:
+  print(f"hello {arg1}")
+
+# this is a job definition handle
+job_def_remote = test_job
+
+job1 = job_def_remote()
+job2 = job_def_remote(arg1="ML Job")
+
+
+```
+
+* Job-based Batch Inference (PuPr): `ModelVersion.run_batch` for job-based batch inference in Snowpark Container
+Services is now in public preview.
+
+```python
+from snowflake.ml.registry import Registry
+from snowflake.ml.model import OutputSpec
+
+registry = Registry(session)
+mv = registry.log_model( ... )
+
+job = mv.run_batch(
+    compute_pool = "SYSTEM_COMPUTE_POOL_GPU",
+    X=input_df,
+    output_spec=OutputSpec(stage_location="@my_db.my_schema.my_stage/output/"),
+)
+```
+
+* Registry: Added support for inference parameters via `ParamSpec` in model signatures. This allows you to define
+  constant parameters that can be passed at inference time without being part of the input data.
+
+```python
+import pandas as pd
+from snowflake.ml.model import custom_model, model_signature
+from snowflake.ml.registry import Registry
+
+# Define a custom model with inference parameters
+class MyModelWithParams(custom_model.CustomModel):
+    @custom_model.inference_api
+    def predict(
+        self,
+        input_df: pd.DataFrame,
+        *,
+        temperature: float = 1.0,  # keyword-only param with default
+    ) -> pd.DataFrame:
+        return pd.DataFrame({"output": input_df["feature"] * temperature})
+
+# Create sample data
+model = MyModelWithParams(custom_model.ModelContext())
+sample_input = pd.DataFrame({"feature": [1.0, 2.0, 3.0]})
+sample_output = model.predict(sample_input, temperature=1.0)
+
+# Define ParamSpec for the inference parameter
+params = [
+    model_signature.ParamSpec(
+        name="temperature",
+        dtype=model_signature.DataType.FLOAT,
+        default_value=1.0,
+    ),
+]
+
+# Infer signature with params
+sig = model_signature.infer_signature(
+    input_data=sample_input,
+    output_data=sample_output,
+    params=params,
+)
+
+# Log model with the signature
+registry = Registry(session)
+mv = registry.log_model(
+    model=model,
+    model_name="my_model_with_params",
+    version_name="v1",
+    signatures={"predict": sig},
+)
+
+# Run inference with custom parameter value
+result = mv.run(sample_input, function_name="predict", params={"temperature": 2.0})
+```
+
+* Feature Store: Added `auto_prefix` parameter and `with_name()` method to avoid column name collisions when
+  joining multiple feature views in dataset generation.
+
+* Feature Store: Added support for Dynamic Iceberg Tables as the backing storage for Feature Views.
+  Use `StorageConfig` with `StorageFormat.ICEBERG` to create Iceberg-backed Feature Views that store
+  data in open Apache Iceberg format on external cloud storage. A new `default_iceberg_external_volume`
+  parameter is available in `FeatureStore` to set a default external volume for Iceberg Feature Views.
+
+### Bug Fixes
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.25.1
+
+### Bug Fixes
+
+* ML Job: Reverted changes related to the introduction of ML Job Definitions.
+
 ## 1.25.0
 
 ### New Features

{snowflake_ml_python-1.25.0 → snowflake_ml_python-1.26.0}/snowflake/ml/_internal/telemetry.py

@@ -692,9 +692,10 @@ def _get_func_params(
     """
     params = {}
     if func_params_to_log:
-        spec = inspect.getfullargspec(func)
+        # Use inspect.signature which automatically follows __wrapped__ attributes
+        sig = inspect.signature(func)
         for field in func_params_to_log:
-            found, extracted_value = _extract_arg_value(field, spec, args, kwargs)
+            found, extracted_value = _extract_arg_value(field, sig, args, kwargs)
             if not found:
                 pass
             else:
@@ -702,13 +703,13 @@ def _get_func_params(
     return params
 
 
-def _extract_arg_value(field: str, func_spec: inspect.FullArgSpec, args: Any, kwargs: Any) -> tuple[bool, Any]:
+def _extract_arg_value(field: str, sig: inspect.Signature, args: Any, kwargs: Any) -> tuple[bool, Any]:
     """
     Function to extract a specified argument value.
 
     Args:
         field: Target function argument name to extract.
-        func_spec: Full argument spec for the function.
+        sig: Function signature (from inspect.signature).
         args: `args` for the invoked function.
         kwargs: `kwargs` for the invoked function.
 
@@ -716,26 +717,27 @@ def _extract_arg_value(field: str, func_spec: inspect.FullArgSpec, args: Any, kw
         Tuple: First value indicates if `field` exists.
         Second value is the extracted value if existed.
     """
-    if field in func_spec.args:
-        idx = func_spec.args.index(field)
+    if field not in sig.parameters:
+        return False, None
+
+    param = sig.parameters[field]
+    param_names = list(sig.parameters.keys())
+    idx = param_names.index(field)
+
+    # Check if value was passed as positional argument
+    if param.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD):
         if idx < len(args):
             return True, args[idx]
-        elif field in kwargs:
-            return True, kwargs[field]
-        else:
-            if func_spec.defaults:
-                required_len = len(func_spec.args) - len(func_spec.defaults)
-                return True, func_spec.defaults[idx - required_len]
-            return False, None
-    elif func_spec.kwonlydefaults and field in func_spec.kwonlyargs:
-        if field in kwargs:
-            return True, kwargs[field]
-        elif field in func_spec.kwonlydefaults:
-            return True, func_spec.kwonlydefaults[field]
-        else:
-            return False, None
-    else:
-        return False, None
+
+    # Check if value was passed as keyword argument
+    if field in kwargs:
+        return True, kwargs[field]
+
+    # Fall back to default value if available
+    if param.default is not inspect.Parameter.empty:
+        return True, param.default
+
+    return False, None
 
 
 class _SourceTelemetryClient:

{snowflake_ml_python-1.25.0 → snowflake_ml_python-1.26.0}/snowflake/ml/_internal/utils/connection_params.py

@@ -189,6 +189,10 @@ def SnowflakeLoginOptions(connection_name: str = "", login_file: Optional[str] =
         conn_prop["token"] = token
         if "authenticator" not in conn_prop or conn_prop["authenticator"]:
             conn_prop["authenticator"] = "oauth"
+        # When using OAuth token, remove user and password as the token determines the user.
+        # Passing a user that differs from the token's user causes authentication failure.
+        conn_prop.pop("user", None)
+        conn_prop.pop("password", None)
     elif "private_key_path" in conn_prop and "private_key" not in conn_prop:
         conn_prop["private_key"] = _load_pem_to_der(str(conn_prop["private_key_path"]))
 

{snowflake_ml_python-1.25.0 → snowflake_ml_python-1.26.0}/snowflake/ml/feature_store/feature.py

@@ -193,20 +193,23 @@ class Feature:
         return cls(AggregationType.MAX, column, window, offset)
 
     @classmethod
-    def std(cls, column: str, window: str, offset: str = "0") -> Feature:
-        """Create a STD (standard deviation) aggregation feature.
+    def stddev(cls, column: str, window: str, offset: str = "0") -> Feature:
+        """Create a STDDEV (standard deviation) aggregation feature.
+
+        Computes the population standard deviation of values within the specified window.
 
         Args:
             column: The column to compute standard deviation for.
-            window: The lookback window.
+            window: The lookback window (e.g., "24h", "7d").
             offset: Offset to shift window into past. Default is "0" (no offset).
 
         Returns:
-            A Feature configured for STD aggregation.
+            A Feature configured for STDDEV aggregation.
 
         Example::
 
-            >>> price_std = Feature.std("price", "24h")
+            >>> price_stddev = Feature.stddev("price", "24h")
+            >>> prev_week_stddev = Feature.stddev("price", "7d", offset="7d")
         """
         return cls(AggregationType.STD, column, window, offset)