snowflake-ml-python 1.6.2__py3-none-any.whl → 1.6.3__py3-none-any.whl

snowflake/ml/feature_store/feature_view.py

@@ -22,6 +22,7 @@ from snowflake.ml.feature_store import feature_store
 from snowflake.ml.feature_store.entity import Entity
 from snowflake.ml.lineage import lineage_node
 from snowflake.snowpark import DataFrame, Session
+from snowflake.snowpark.exceptions import SnowparkSQLException
 from snowflake.snowpark.types import (
     DateType,
     StructType,
@@ -167,6 +168,7 @@ class FeatureView(lineage_node.LineageNode):
         refresh_freq: Optional[str] = None,
         desc: str = "",
         warehouse: Optional[str] = None,
+        initialize: str = "ON_CREATE",
         **_kwargs: Any,
     ) -> None:
         """
@@ -190,6 +192,10 @@ class FeatureView(lineage_node.LineageNode):
             warehouse: warehouse to refresh feature view. Not needed for static feature view (refresh_freq is None).
                 For managed feature view, this warehouse will overwrite the default warehouse of Feature Store if it is
                 specified, otherwise the default warehouse will be used.
+            initialize: Specifies the behavior of the initial refresh of feature view. This property cannot be altered
+                after you register the feature view. It supports ON_CREATE (default) or ON_SCHEDULE. ON_CREATE refreshes
+                the feature view synchronously at creation. ON_SCHEDULE refreshes the feature view at the next scheduled
+                refresh. It is only effective when refresh_freq is not None.
             _kwargs: reserved kwargs for system generated args. NOTE: DO NOT USE.
 
         Example::
@@ -227,10 +233,14 @@ class FeatureView(lineage_node.LineageNode):
         self._query: str = self._get_query()
         self._version: Optional[FeatureViewVersion] = None
         self._status: FeatureViewStatus = FeatureViewStatus.DRAFT
-        self._feature_desc: OrderedDict[SqlIdentifier, str] = OrderedDict((f, "") for f in self._get_feature_names())
+        feature_names = self._get_feature_names()
+        self._feature_desc: Optional[OrderedDict[SqlIdentifier, str]] = (
+            OrderedDict((f, "") for f in feature_names) if feature_names is not None else None
+        )
         self._refresh_freq: Optional[str] = refresh_freq
         self._database: Optional[SqlIdentifier] = None
         self._schema: Optional[SqlIdentifier] = None
+        self._initialize: str = initialize
         self._warehouse: Optional[SqlIdentifier] = SqlIdentifier(warehouse) if warehouse is not None else None
         self._refresh_mode: Optional[str] = _kwargs.get("refresh_mode", "AUTO")
         self._refresh_mode_reason: Optional[str] = None
@@ -345,6 +355,15 @@ class FeatureView(lineage_node.LineageNode):
                 ('START_STATION_LATITUDE', 'Latitude of the start station.')])
 
         """
+        if self._feature_desc is None:
+            warnings.warn(
+                "Failed to read feature view schema. Probably feature view is not refreshed yet. "
+                "Schema will be available after initial refresh.",
+                stacklevel=2,
+                category=UserWarning,
+            )
+            return self
+
         for f, d in descs.items():
             f = SqlIdentifier(f)
             if f not in self._feature_desc:
@@ -424,10 +443,10 @@ class FeatureView(lineage_node.LineageNode):
 
     @property
     def feature_names(self) -> List[SqlIdentifier]:
-        return list(self._feature_desc.keys())
+        return list(self._feature_desc.keys()) if self._feature_desc is not None else []
 
     @property
-    def feature_descs(self) -> Dict[SqlIdentifier, str]:
+    def feature_descs(self) -> Optional[Dict[SqlIdentifier, str]]:
         return self._feature_desc
 
     def list_columns(self) -> DataFrame:
@@ -463,7 +482,17 @@ class FeatureView(lineage_node.LineageNode):
 
         """
         session = self._feature_df.session
-        rows = []
+        rows = []  # type: ignore[var-annotated]
+
+        if self.feature_descs is None:
+            warnings.warn(
+                "Failed to read feature view schema. Probably feature view is not refreshed yet. "
+                "Schema will be available after initial refresh.",
+                stacklevel=2,
+                category=UserWarning,
+            )
+            return session.create_dataframe(rows, schema=["name", "category", "dtype", "desc"])
+
         for name, type in self._feature_df.dtypes:
             if SqlIdentifier(name) in self.feature_descs:
                 desc = self.feature_descs[SqlIdentifier(name)]
@@ -565,6 +594,10 @@ class FeatureView(lineage_node.LineageNode):
         )
         self._warehouse = SqlIdentifier(new_value)
 
+    @property
+    def initialize(self) -> str:
+        return self._initialize
+
     @property
     def output_schema(self) -> StructType:
         return self._infer_schema_df.schema
@@ -601,33 +634,49 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
                 f"FeatureView name `{self._name}` contains invalid character `{_FEATURE_VIEW_NAME_DELIMITER}`."
             )
 
-        unescaped_df_cols = to_sql_identifiers(self._infer_schema_df.columns)
-        for e in self._entities:
-            for k in e.join_keys:
-                if k not in unescaped_df_cols:
-                    raise ValueError(
-                        f"join_key {k} in Entity {e.name} is not found in input dataframe: {unescaped_df_cols}"
-                    )
-
-        if self._timestamp_col is not None:
-            ts_col = self._timestamp_col
-            if ts_col == SqlIdentifier(_TIMESTAMP_COL_PLACEHOLDER):
-                raise ValueError(f"Invalid timestamp_col name, cannot be {_TIMESTAMP_COL_PLACEHOLDER}.")
-            if ts_col not in to_sql_identifiers(self._infer_schema_df.columns):
-                raise ValueError(f"timestamp_col {ts_col} is not found in input dataframe.")
-
-            col_type = self._infer_schema_df.schema[ts_col].datatype
-            if not isinstance(col_type, (DateType, TimeType, TimestampType, _NumericType)):
-                raise ValueError(f"Invalid data type for timestamp_col {ts_col}: {col_type}.")
+        df_cols = self._get_column_names()
+        if df_cols is not None:
+            for e in self._entities:
+                for k in e.join_keys:
+                    if k not in df_cols:
+                        raise ValueError(f"join_key {k} in Entity {e.name} is not found in input dataframe: {df_cols}")
+
+            if self._timestamp_col is not None:
+                ts_col = self._timestamp_col
+                if ts_col == SqlIdentifier(_TIMESTAMP_COL_PLACEHOLDER):
+                    raise ValueError(f"Invalid timestamp_col name, cannot be {_TIMESTAMP_COL_PLACEHOLDER}.")
+                if ts_col not in df_cols:
+                    raise ValueError(f"timestamp_col {ts_col} is not found in input dataframe.")
+
+                col_type = self._infer_schema_df.schema[ts_col].datatype
+                if not isinstance(col_type, (DateType, TimeType, TimestampType, _NumericType)):
+                    raise ValueError(f"Invalid data type for timestamp_col {ts_col}: {col_type}.")
 
         if re.match(_RESULT_SCAN_QUERY_PATTERN, self._query) is not None:
             raise ValueError(f"feature_df should not be reading from RESULT_SCAN. Invalid query: {self._query}")
 
-    def _get_feature_names(self) -> List[SqlIdentifier]:
+        if self._initialize not in ["ON_CREATE", "ON_SCHEDULE"]:
+            raise ValueError("'initialize' only supports ON_CREATE or ON_SCHEDULE.")
+
+    def _get_column_names(self) -> Optional[List[SqlIdentifier]]:
+        try:
+            return to_sql_identifiers(self._infer_schema_df.columns)
+        except SnowparkSQLException as e:
+            warnings.warn(
+                "Failed to read feature view schema. Probably feature view is not refreshed yet. "
+                f"Schema will be available after initial refresh. Original exception: {e}",
+                stacklevel=2,
+                category=UserWarning,
+            )
+            return None
+
+    def _get_feature_names(self) -> Optional[List[SqlIdentifier]]:
         join_keys = [k for e in self._entities for k in e.join_keys]
         ts_col = [self._timestamp_col] if self._timestamp_col is not None else []
-        feature_names = to_sql_identifiers(self._infer_schema_df.columns, case_sensitive=False)
-        return [c for c in feature_names if c not in join_keys + ts_col]
+        feature_names = self._get_column_names()
+        if feature_names is not None:
+            return [c for c in feature_names if c not in join_keys + ts_col]
+        return None
 
     def __repr__(self) -> str:
         states = (f"{k}={v}" for k, v in vars(self).items())
@@ -670,11 +719,13 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
         fv_dict["_schema"] = str(self._schema) if self._schema is not None else None
         fv_dict["_warehouse"] = str(self._warehouse) if self._warehouse is not None else None
         fv_dict["_timestamp_col"] = str(self._timestamp_col) if self._timestamp_col is not None else None
+        fv_dict["_initialize"] = str(self._initialize)
 
         feature_desc_dict = {}
-        for k, v in self._feature_desc.items():
-            feature_desc_dict[k.identifier()] = v
-        fv_dict["_feature_desc"] = feature_desc_dict
+        if self._feature_desc is not None:
+            for k, v in self._feature_desc.items():
+                feature_desc_dict[k.identifier()] = v
+            fv_dict["_feature_desc"] = feature_desc_dict
 
         lineage_node_keys = [key for key in fv_dict if key.startswith("_node") or key == "_session"]
 
@@ -760,6 +811,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
             warehouse=json_dict["_warehouse"],
             refresh_mode=json_dict["_refresh_mode"],
             refresh_mode_reason=json_dict["_refresh_mode_reason"],
+            initialize=json_dict["_initialize"],
             owner=json_dict["_owner"],
             infer_schema_df=session.sql(json_dict.get("_infer_schema_query", None)),
             session=session,
@@ -830,6 +882,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
         warehouse: Optional[str],
         refresh_mode: Optional[str],
         refresh_mode_reason: Optional[str],
+        initialize: str,
         owner: Optional[str],
         infer_schema_df: Optional[DataFrame],
         session: Session,
@@ -850,6 +903,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
         fv._warehouse = SqlIdentifier(warehouse) if warehouse is not None else None
         fv._refresh_mode = refresh_mode
         fv._refresh_mode_reason = refresh_mode_reason
+        fv._initialize = initialize
         fv._owner = owner
         fv.attach_feature_desc(feature_descs)
 

snowflake/ml/fileset/stage_fs.py

@@ -431,4 +431,5 @@ def _resolve_async_job(async_job: snowpark.AsyncJob) -> List[snowpark.Row]:
                 error_code=error_codes.SNOWML_NOT_FOUND,
                 original_exception=fileset_errors.StageNotFoundError("Query failed."),
             ) from e
-        raise
+        assert e.msg is not None
+        raise snowpark_exceptions.SnowparkSQLException(e.msg, conn_error=e) from e

snowflake/ml/lineage/lineage_node.py

@@ -118,16 +118,21 @@ class LineageNode:
             )
             domain = lineage_object["domain"].lower()
             if domain_filter is None or domain in domain_filter:
+                obj_name = ".".join(
+                    identifier.rename_to_valid_snowflake_identifier(s)
+                    for s in identifier.parse_schema_level_object_identifier(lineage_object["name"])
+                    if s is not None
+                )
                 if domain in DOMAIN_LINEAGE_REGISTRY and lineage_object["status"] == "ACTIVE":
                     lineage_nodes.append(
                         DOMAIN_LINEAGE_REGISTRY[domain]._load_from_lineage_node(
-                            self._session, lineage_object["name"], lineage_object.get("version")
+                            self._session, obj_name, lineage_object.get("version")
                         )
                     )
                 else:
                     lineage_nodes.append(
                         LineageNode(
-                            name=lineage_object["name"],
+                            name=obj_name,
                             version=lineage_object.get("version"),
                             domain=domain,
                             status=lineage_object["status"],

snowflake/ml/model/__init__.py

@@ -1,6 +1,5 @@
 from snowflake.ml.model._client.model.model_impl import Model
 from snowflake.ml.model._client.model.model_version_impl import ExportMode, ModelVersion
 from snowflake.ml.model.models.huggingface_pipeline import HuggingFacePipelineModel
-from snowflake.ml.model.models.llm import LLM, LLMOptions
 
-__all__ = ["Model", "ModelVersion", "ExportMode", "HuggingFacePipelineModel", "LLM", "LLMOptions"]
+__all__ = ["Model", "ModelVersion", "ExportMode", "HuggingFacePipelineModel"]

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

@@ -310,12 +310,12 @@ class ModelVersion(lineage_node.LineageNode):
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,
     )
-    def get_model_objective(self) -> model_types.ModelObjective:
+    def get_model_task(self) -> model_types.Task:
         statement_params = telemetry.get_statement_params(
             project=_TELEMETRY_PROJECT,
             subproject=_TELEMETRY_SUBPROJECT,
         )
-        return self._model_ops.get_model_objective(
+        return self._model_ops.get_model_task(
             database_name=None,
             schema_name=None,
             model_name=self._model_name,
@@ -423,6 +423,7 @@ class ModelVersion(lineage_node.LineageNode):
             partition_column = sql_identifier.SqlIdentifier(partition_column)
 
         functions: List[model_manifest_schema.ModelFunctionInfo] = self._functions
+
         if function_name:
             req_method_name = sql_identifier.SqlIdentifier(function_name).identifier()
             find_method: Callable[[model_manifest_schema.ModelFunctionInfo], bool] = (
@@ -625,6 +626,7 @@ class ModelVersion(lineage_node.LineageNode):
             "image_repo",
             "gpu_requests",
             "num_workers",
+            "max_batch_rows",
         ],
     )
     def create_service(
@@ -638,6 +640,7 @@ class ModelVersion(lineage_node.LineageNode):
         max_instances: int = 1,
         gpu_requests: Optional[str] = None,
         num_workers: Optional[int] = None,
+        max_batch_rows: Optional[int] = None,
         force_rebuild: bool = False,
         build_external_access_integration: str,
     ) -> str:
@@ -646,22 +649,27 @@ class ModelVersion(lineage_node.LineageNode):
         Args:
             service_name: The name of the service, can be fully qualified. If not fully qualified, the database or
                 schema of the model will be used.
-            image_build_compute_pool: The name of the compute pool used to build the model inference image. Use
+            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.
             service_compute_pool: The name of the compute pool used to run the inference service.
             image_repo: The name of the image repository, can be fully qualified. If not fully qualified, the database
                 or schema of the model will be used.
-            ingress_enabled: Whether to enable ingress.
-            max_instances: The maximum number of inference service instances to run.
+            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.
             gpu_requests: The gpu limit for GPU based inference. Can be integer, fractional or string values. Use CPU
                 if None.
-            num_workers: The number of workers (replicas of models) to run the inference service.
-                Auto determined if None.
+            num_workers: The number of workers to run the inference service for handling requests in parallel within an
+                instance of the service. By default, it is set to 2*vCPU+1 of the node for CPU based inference and 1 for
+                GPU based inference. For GPU based inference, please see best practices before playing with this value.
+            max_batch_rows: The maximum number of rows to batch for inference. Auto determined if None. Minimum 32.
             force_rebuild: Whether to force a model inference image rebuild.
-            build_external_access_integration: The external access integration for image build.
+            build_external_access_integration: The external access integration for image build. This is usually
+                permitting access to conda & PyPI repositories.
 
         Returns:
-            The service name.
+            Result information about service creation from server.
         """
         statement_params = telemetry.get_statement_params(
             project=_TELEMETRY_PROJECT,
@@ -690,10 +698,71 @@ class ModelVersion(lineage_node.LineageNode):
             max_instances=max_instances,
             gpu_requests=gpu_requests,
             num_workers=num_workers,
+            max_batch_rows=max_batch_rows,
             force_rebuild=force_rebuild,
             build_external_access_integration=sql_identifier.SqlIdentifier(build_external_access_integration),
             statement_params=statement_params,
         )
 
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def list_services(
+        self,
+    ) -> List[str]:
+        """List all the service names using this model version.
+
+        Returns:
+            List of service_names: The name of the service, can be fully qualified. If not fully qualified, the database
+                or schema of the model will be used.
+        """
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+
+        return self._model_ops.list_inference_services(
+            database_name=None,
+            schema_name=None,
+            model_name=self._model_name,
+            version_name=self._version_name,
+            statement_params=statement_params,
+        )
+
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def delete_service(
+        self,
+        service_name: str,
+    ) -> None:
+        """Drops the given service.
+
+        Args:
+            service_name: The name of the service, can be fully qualified. If not fully qualified, the database or
+                schema of the model will be used.
+
+        Raises:
+            ValueError: If the service does not exist or operation is not permitted by user or service does not belong
+                to this model.
+        """
+        if not service_name:
+            raise ValueError("service_name cannot be empty.")
+
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        self._model_ops.delete_service(
+            database_name=None,
+            schema_name=None,
+            model_name=self._model_name,
+            version_name=self._version_name,
+            service_name=service_name,
+            statement_params=statement_params,
+        )
+
 
 lineage_node.DOMAIN_LINEAGE_REGISTRY["model"] = ModelVersion

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

@@ -1,3 +1,4 @@
+import json
 import os
 import pathlib
 import tempfile
@@ -6,6 +7,7 @@ from typing import Any, Dict, List, Literal, Optional, Union, cast, overload
 
 import yaml
 
+from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml._internal.utils import formatting, identifier, sql_identifier
 from snowflake.ml.model import model_signature, type_hints
 from snowflake.ml.model._client.ops import metadata_ops
@@ -512,6 +514,71 @@ class ModelOperator:
             statement_params=statement_params,
         )
 
+    def list_inference_services(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> List[str]:
+        res = self._model_client.show_versions(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
+        col_name = self._model_client.MODEL_VERSION_INFERENCE_SERVICES_COL_NAME
+        if col_name not in res[0]:
+            # User need to opt into BCR 2024_08
+            raise exceptions.SnowflakeMLException(
+                error_code=error_codes.OPT_IN_REQUIRED,
+                original_exception=RuntimeError(
+                    "Please opt in to BCR Bundle 2024_08 ("
+                    "https://docs.snowflake.com/en/release-notes/bcr-bundles/2024_08_bundle)."
+                ),
+            )
+        json_array = json.loads(res[0][col_name])
+        # TODO(sdas): Figure out a better way to filter out MODEL_BUILD_ services server side.
+        return [str(service) for service in json_array if "MODEL_BUILD_" not in service]
+
+    def delete_service(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        service_name: str,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        services = self.list_inference_services(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
+        db, schema, service_name = sql_identifier.parse_fully_qualified_name(service_name)
+        fully_qualified_service_name = sql_identifier.get_fully_qualified_name(
+            db, schema, service_name, self._session.get_current_database(), self._session.get_current_schema()
+        )
+
+        for service in services:
+            if service == fully_qualified_service_name:
+                self._service_client.drop_service(
+                    database_name=db,
+                    schema_name=schema,
+                    service_name=service_name,
+                    statement_params=statement_params,
+                )
+                return
+        raise ValueError(
+            f"Service '{service_name}' does not exist or unauthorized or not associated with this model version."
+        )
+
     def get_model_version_manifest(
         self,
         *,
@@ -538,7 +605,8 @@ class ModelOperator:
     def _match_model_spec_with_sql_functions(
         sql_functions_names: List[sql_identifier.SqlIdentifier], target_methods: List[str]
     ) -> Dict[sql_identifier.SqlIdentifier, str]:
-        res = {}
+        res: Dict[sql_identifier.SqlIdentifier, str] = {}
+
         for target_method in target_methods:
             # Here we need to find the SQL function corresponding to the Python function.
             # If the python function name is `abc`, then SQL function name can be `ABC` or `"abc"`.
@@ -574,7 +642,7 @@ class ModelOperator:
         model_spec = model_meta.ModelMetadata._validate_model_metadata(model_spec_dict)
         return model_spec
 
-    def get_model_objective(
+    def get_model_task(
         self,
         *,
         database_name: Optional[sql_identifier.SqlIdentifier],
@@ -582,7 +650,7 @@ class ModelOperator:
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[Dict[str, Any]] = None,
-    ) -> type_hints.ModelObjective:
+    ) -> type_hints.Task:
         model_spec = self._fetch_model_spec(
             database_name=database_name,
             schema_name=schema_name,
@@ -590,8 +658,8 @@ class ModelOperator:
             version_name=version_name,
             statement_params=statement_params,
         )
-        model_objective_val = model_spec.get("model_objective", type_hints.ModelObjective.UNKNOWN.value)
-        return type_hints.ModelObjective(model_objective_val)
+        task_val = model_spec.get("task", type_hints.Task.UNKNOWN.value)
+        return type_hints.Task(task_val)
 
     def get_functions(
         self,
@@ -633,6 +701,20 @@ class ModelOperator:
 
             function_names_and_types.append((function_name, function_type))
 
+        if not function_names_and_types:
+            # If function_names_and_types is not populated, there are currently
+            # no warehouse functions for the model version. In order to do inference
+            # we must populate the functions so the mapping can be constructed.
+            model_manifest = self.get_model_version_manifest(
+                database_name=database_name,
+                schema_name=schema_name,
+                model_name=model_name,
+                version_name=version_name,
+                statement_params=statement_params,
+            )
+            for method in model_manifest["methods"]:
+                function_names_and_types.append((sql_identifier.SqlIdentifier(method["name"]), method["type"]))
+
         signatures = model_spec["signatures"]
         function_names = [name for name, _ in function_names_and_types]
         function_name_mapping = ModelOperator._match_model_spec_with_sql_functions(
@@ -799,7 +881,7 @@ class ModelOperator:
 
         if keep_order:
             # if it's a partitioned table function, _ID will be null and we won't be able to sort.
-            if df_res.select("_ID").limit(1).collect()[0][0] is None:
+            if df_res.select(snowpark_handler._KEEP_ORDER_COL_NAME).limit(1).collect()[0][0] is None:
                 warnings.warn(
                     formatting.unwrap(
                         """
@@ -812,7 +894,7 @@ class ModelOperator:
                 )
             else:
                 df_res = df_res.sort(
-                    "_ID",
+                    snowpark_handler._KEEP_ORDER_COL_NAME,
                     ascending=True,
                 )