snowflake-ml-python 1.6.4__py3-none-any.whl → 1.7.1__py3-none-any.whl

snowflake/cortex/_sse_client.py

@@ -1,73 +1,125 @@
-from typing import Iterator, cast
+import json
+from typing import Any, Iterator, Optional
 
-import requests
+_FIELD_SEPARATOR = ":"
 
 
 class Event:
-    def __init__(self, event: str = "message", data: str = "") -> None:
+    """Representation of an event from the event stream."""
+
+    def __init__(
+        self,
+        id: Optional[str] = None,
+        event: str = "message",
+        data: str = "",
+        comment: Optional[str] = None,
+        retry: Optional[int] = None,
+    ) -> None:
+        self.id = id
         self.event = event
         self.data = data
+        self.comment = comment
+        self.retry = retry
 
     def __str__(self) -> str:
         s = f"{self.event} event"
+        if self.id:
+            s += f" #{self.id}"
         if self.data:
-            s += f", {len(self.data)} bytes"
+            s += ", {} byte{}".format(len(self.data), "s" if len(self.data) else "")
         else:
             s += ", no data"
+        if self.comment:
+            s += f", comment: {self.comment}"
+        if self.retry:
+            s += f", retry in {self.retry}ms"
         return s
 
 
+# This is copied from the snowpy library:
+# https://github.com/snowflakedb/snowpy/blob/main/libs/snowflake.core/src/snowflake/core/rest.py#L39
+# TODO(SNOW-1750723) - Current there’s code duplication across snowflake-ml-python
+# and snowpy library for Cortex REST API which was done to meet our GA timelines
+# Once snowpy has a release with https://github.com/snowflakedb/snowpy/pull/679, we should
+# remove the class here and directly refer from the snowflake.core package directly
 class SSEClient:
-    def __init__(self, response: requests.Response) -> None:
+    def __init__(self, event_source: Any, char_enc: str = "utf-8") -> None:
+        self._event_source = event_source
+        self._char_enc = char_enc
 
-        self.response = response
-
-    def _read(self) -> Iterator[str]:
-
-        lines = b""
-        for chunk in self.response:
+    def _read(self) -> Iterator[bytes]:
+        data = b""
+        for chunk in self._event_source:
             for line in chunk.splitlines(True):
-                lines += line
-                if lines.endswith((b"\r\r", b"\n\n", b"\r\n\r\n")):
-                    yield cast(str, lines)
-                    lines = b""
-        if lines:
-            yield cast(str, lines)
+                data += line
+                if data.endswith((b"\r\r", b"\n\n", b"\r\n\r\n")):
+                    yield data
+                    data = b""
+        if data:
+            yield data
 
     def events(self) -> Iterator[Event]:
-        for raw_event in self._read():
+        content_type = self._event_source.headers.get("Content-Type")
+        # The check for empty content-type is present because it's being populated after
+        # the change in https://github.com/snowflakedb/snowflake/pull/217654.
+        # This can be removed once the above change makes it to prod or we move to snowpy
+        # for SSEClient implementation.
+        if content_type == "text/event-stream" or not content_type:
+            return self._handle_sse()
+        elif content_type == "application/json":
+            return self._handle_json()
+        else:
+            raise ValueError(f"Unknown Content-Type: {content_type}")
+
+    def _handle_sse(self) -> Iterator[Event]:
+        for chunk in self._read():
             event = Event()
-            # splitlines() only uses \r and \n
-            for line in raw_event.splitlines():
+            # Split before decoding so splitlines() only uses \r and \n
+            for line_bytes in chunk.splitlines():
+                # Decode the line.
+                line = line_bytes.decode(self._char_enc)
 
-                line = cast(bytes, line).decode("utf-8")
+                # Lines starting with a separator are comments and are to be
+                # ignored.
+                if not line.strip() or line.startswith(_FIELD_SEPARATOR):
+                    continue
 
-                data = line.split(":", 1)
+                data = line.split(_FIELD_SEPARATOR, 1)
                 field = data[0]
 
+                # Ignore unknown fields.
+                if not hasattr(event, field):
+                    continue
+
                 if len(data) > 1:
+                    # From the spec:
                     # "If value starts with a single U+0020 SPACE character,
-                    # remove it from value. .strip() would remove all white spaces"
+                    # remove it from value."
                     if data[1].startswith(" "):
                         value = data[1][1:]
                     else:
                         value = data[1]
                 else:
+                    # If no value is present after the separator,
+                    # assume an empty value.
                     value = ""
 
                 # The data field may come over multiple lines and their values
                 # are concatenated with each other.
+                current_value = getattr(event, field, "")
                 if field == "data":
-                    event.data += value + "\n"
-                elif field == "event":
-                    event.event = value
+                    new_value = current_value + value + "\n"
+                else:
+                    new_value = value
+                setattr(event, field, new_value)
 
+            # Events with no data are not dispatched.
             if not event.data:
                 continue
 
             # If the data field ends with a newline, remove it.
             if event.data.endswith("\n"):
-                event.data = event.data[0:-1]  # Replace trailing newline - rstrip would remove multiple.
+                event.data = event.data[0:-1]
 
             # Empty event names default to 'message'
             event.event = event.event or "message"
@@ -77,5 +129,16 @@ class SSEClient:
 
             yield event
 
+    def _handle_json(self) -> Iterator[Event]:
+        data_list = json.loads(self._event_source.data.decode(self._char_enc))
+        for data in data_list:
+            yield Event(
+                id=data.get("id"),
+                event=data.get("event"),
+                data=data.get("data"),
+                comment=data.get("comment"),
+                retry=data.get("retry"),
+            )
+
     def close(self) -> None:
-        self.response.close()
+        self._event_source.close()

snowflake/cortex/_util.py

@@ -1,6 +1,8 @@
-from typing import Dict, List, Optional, Union, cast
+from typing import Any, Dict, List, Optional, Union, cast
 
 from snowflake import snowpark
+from snowflake.ml._internal.exceptions import error_codes, exceptions
+from snowflake.ml._internal.utils import formatting
 from snowflake.snowpark import context, functions
 
 CORTEX_FUNCTIONS_TELEMETRY_PROJECT = "CortexFunctions"
@@ -64,3 +66,30 @@ def _call_sql_function_immediate(
     empty_df = session.create_dataframe([snowpark.Row()])
     df = empty_df.select(functions.builtin(function)(*lit_args))
     return cast(str, df.collect()[0][0])
+
+
+def call_sql_function_literals(function: str, session: Optional[snowpark.Session], *args: Any) -> str:
+    r"""Call a SQL function with only literal arguments.
+
+    This is useful for calling system functions.
+
+    Args:
+        function: The name of the function to be called.
+        session: The Snowpark session to use.
+        *args: The list of arguments
+
+    Returns:
+        String value that corresponds the the first cell in the dataframe.
+
+    Raises:
+        SnowflakeMLException: If no session is given and no active session exists.
+    """
+    if session is None:
+        session = context.get_active_session()
+    if session is None:
+        raise exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_SNOWPARK_SESSION,
+        )
+
+    function_arguments = ",".join(["NULL" if arg is None else formatting.format_value_for_select(arg) for arg in args])
+    return cast(str, session.sql(f"SELECT {function}({function_arguments})").collect()[0][0])

snowflake/ml/_internal/telemetry.py

@@ -544,7 +544,7 @@ def send_api_usage_telemetry(
                 if not isinstance(e, snowml_exceptions.SnowflakeMLException):
                     # already handled via a nested decorated function
                     if getattr(e, "_snowflake_ml_handled", False):
-                        raise e
+                        raise
                     if isinstance(e, snowpark_exceptions.SnowparkClientException):
                         me = snowml_exceptions.SnowflakeMLException(
                             error_code=error_codes.INTERNAL_SNOWPARK_ERROR, original_exception=e
@@ -558,7 +558,9 @@ def send_api_usage_telemetry(
                 telemetry_args["error"] = repr(me)
                 telemetry_args["error_code"] = me.error_code
                 me.original_exception._snowflake_ml_handled = True  # type: ignore[attr-defined]
-                if me.suppress_source_trace:
+                if e is not me:
+                    raise  # Directly raise non-wrapped exceptions to preserve original stacktrace
+                elif me.suppress_source_trace:
                     raise me.original_exception from None
                 else:
                     raise me.original_exception from e

snowflake/ml/_internal/type_utils.py

@@ -1,4 +1,4 @@
-import sys
+import importlib
 from typing import Any, Generic, Type, TypeVar, Union, cast
 
 import numpy as np
@@ -51,8 +51,8 @@ class LazyType(Generic[T]):
     def get_class(self) -> Type[T]:
         if self._runtime_class is None:
             try:
-                m = sys.modules[self.module]
-            except KeyError:
+                m = importlib.import_module(self.module)
+            except ModuleNotFoundError:
                 raise ValueError(f"Module {self.module} not imported.")
 
             self._runtime_class = cast("Type[T]", getattr(m, self.qualname))

snowflake/ml/_internal/utils/import_utils.py

@@ -19,6 +19,33 @@ class MissingOptionalDependency:
         raise ImportError(f"Unable to import {self._dep_name}.")
 
 
+def import_with_fallbacks(*targets: str) -> Any:
+    """Import a module which may be located in different locations.
+
+    This method will iterate through the provided targets, returning the first available import target.
+    If none of the requested import targets are available, ImportError will be raised.
+
+    Args:
+        targets: Strings representing the target which needs to be imported. It should be a list of symbol name
+            joined by dot. Some valid examples:
+                - <some_package>
+                - <some_module>
+                - <some_package>.<some_module>
+                - <some_module>.<some_symbol>
+
+    Returns:
+        The imported target.
+
+    Raises:
+        ImportError: None of the requested targets are available
+    """
+    for target in targets:
+        result, success = import_or_get_dummy(target)
+        if success:
+            return result
+    raise ImportError(f"None of the requested targets could be imported. Requested: {', '.join(targets)}")
+
+
 def import_or_get_dummy(target: str) -> Tuple[Any, bool]:
     """Try to import the the given target or return a dummy object.
 
@@ -43,6 +70,10 @@ def import_or_get_dummy(target: str) -> Tuple[Any, bool]:
     except ImportError:
         pass
 
+    # Don't try symbol resolution if target doesn't contain '.'
+    if "." not in target:
+        return (MissingOptionalDependency(target), False)
+
     # Try to import the target as a symbol
     try:
         res = _try_import_symbol(target)

snowflake/ml/_internal/utils/snowpark_dataframe_utils.py

@@ -121,3 +121,16 @@ def cast_snowpark_dataframe_column_types(df: snowpark.DataFrame) -> snowpark.Dat
             selected_cols.append(functions.col(src))
     df = df.select(selected_cols)
     return df
+
+
+def is_single_query_snowpark_dataframe(df: snowpark.DataFrame) -> bool:
+    """Check if dataframe only has a single query.
+
+    Args:
+        df: A snowpark dataframe.
+
+    Returns:
+        true if there is only on query in the dataframe and no post_actions,
+        false otherwise.
+    """
+    return len(df.queries["queries"]) == 1 and len(df.queries["post_actions"]) == 0

snowflake/ml/data/__init__.py

@@ -0,0 +1,5 @@
+from .data_connector import DataConnector
+from .data_ingestor import DataIngestor, DataIngestorType
+from .data_source import DataFrameInfo, DatasetInfo, DataSource
+
+__all__ = ["DataConnector", "DataSource", "DataFrameInfo", "DatasetInfo", "DataIngestor", "DataIngestorType"]

snowflake/ml/data/_internal/arrow_ingestor.py

@@ -198,7 +198,15 @@ def _record_batch_to_arrays(rb: pa.RecordBatch) -> Dict[str, npt.NDArray[Any]]:
     for column, column_schema in zip(rb, rb.schema):
         # zero_copy_only=False because of nans. Ideally nans should have been imputed in feature engineering.
         array = column.to_numpy(zero_copy_only=False)
+        # If this column is a list, use the underlying type from the list values. Since this is just one column,
+        # there should only be one type within the list.
+        # TODO: Refactor to reduce data copies.
+        if isinstance(column_schema.type, pa.ListType):
+            # Update dtype of outer array:
+            array = np.array(array.tolist(), dtype=column_schema.type.value_type.to_pandas_dtype())
+
         batch_dict[column_schema.name] = array
+
     return batch_dict
 
 

snowflake/ml/data/data_connector.py

@@ -159,7 +159,7 @@ class DataConnector:
         func_params_to_log=["batch_size", "shuffle", "drop_last_batch"],
     )
     def to_torch_dataset(
-        self, *, batch_size: int = 1, shuffle: bool = False, drop_last_batch: bool = True
+        self, *, batch_size: Optional[int] = None, shuffle: bool = False, drop_last_batch: bool = True
     ) -> "torch_data.IterableDataset":  # type: ignore[type-arg]
         """Transform the Snowflake data into a PyTorch Iterable Dataset to be used with a DataLoader.
 

snowflake/ml/data/torch_utils.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Iterator, List, Union
+from typing import Any, Dict, Iterator, List, Optional, Union
 
 import numpy as np
 import numpy.typing as npt
@@ -14,17 +14,21 @@ class TorchDatasetWrapper(torch.utils.data.IterableDataset[Dict[str, Any]]):
         self,
         ingestor: data_ingestor.DataIngestor,
         *,
-        batch_size: int,
+        batch_size: Optional[int],
         shuffle: bool = False,
         drop_last: bool = False,
-        squeeze_outputs: bool = True
     ) -> None:
         """Not intended for direct usage. Use DataConnector.to_torch_dataset() instead"""
+        squeeze = False
+        if batch_size is None:
+            batch_size = 1
+            squeeze = True
+
         self._ingestor = ingestor
         self._batch_size = batch_size
         self._shuffle = shuffle
         self._drop_last = drop_last
-        self._squeeze_outputs = squeeze_outputs
+        self._squeeze_outputs = squeeze
 
     def __iter__(self) -> Iterator[Dict[str, Union[npt.NDArray[Any], List[Any]]]]:
         max_idx = 0
@@ -43,15 +47,7 @@ class TorchDatasetWrapper(torch.utils.data.IterableDataset[Dict[str, Any]]):
         ):
             # Skip indices during multi-process data loading to prevent data duplication
             if counter == filter_idx:
-                # Basic preprocessing on batch values: squeeze away extra dimensions
-                # and convert object arrays (e.g. strings) to lists
-                if self._squeeze_outputs:
-                    yield {
-                        k: (v.squeeze().tolist() if v.dtype == np.object_ else v.squeeze()) for k, v in batch.items()
-                    }
-                else:
-                    yield batch  # type: ignore[misc]
-
+                yield {k: _preprocess_array(v, squeeze=self._squeeze_outputs) for k, v in batch.items()}
             if counter < max_idx:
                 counter += 1
             else:
@@ -65,4 +61,27 @@ class TorchDataPipeWrapper(TorchDatasetWrapper, torch.utils.data.IterDataPipe[Di
         self, ingestor: data_ingestor.DataIngestor, *, batch_size: int, shuffle: bool = False, drop_last: bool = False
     ) -> None:
         """Not intended for direct usage. Use DataConnector.to_torch_datapipe() instead"""
-        super().__init__(ingestor, batch_size=batch_size, shuffle=shuffle, drop_last=drop_last, squeeze_outputs=False)
+        super().__init__(ingestor, batch_size=batch_size, shuffle=shuffle, drop_last=drop_last)
+
+
+def _preprocess_array(arr: npt.NDArray[Any], squeeze: bool = False) -> Union[npt.NDArray[Any], List[np.object_]]:
+    """Preprocesses batch column values."""
+    single_dimensional = arr.ndim < 2 and not arr.dtype == np.object_
+
+    # Squeeze away all extra dimensions. This is only used when batch_size = None.
+    if squeeze:
+        arr = arr.squeeze(axis=0)
+
+    # For single dimensional data,
+    if single_dimensional:
+        axis = 0 if arr.ndim == 0 else 1
+        arr = np.expand_dims(arr, axis=axis)
+
+    # Handle object arrays.
+    if arr.dtype == np.object_:
+        array_list = arr.tolist()
+        # If this is an array of arrays, convert the dtype to match the underlying array.
+        # Otherwise, if this is a numpy array of strings, convert the array to a list.
+        arr = np.array(array_list, dtype=arr.flat[0].dtype) if isinstance(arr.flat[0], np.ndarray) else array_list
+
+    return arr

snowflake/ml/feature_store/examples/airline_features/features/plane_features.py

@@ -6,15 +6,17 @@ from snowflake.snowpark import DataFrame, Session
 
 
 # This function will be invoked by example_helper.py. Do not change the name.
-def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], source_tables: List[str]) -> FeatureView:
+def create_draft_feature_view(
+    session: Session, source_dfs: List[DataFrame], source_tables: List[str], database: str, schema: str
+) -> FeatureView:
     """Create a feature view about airplane model."""
     query = session.sql(
-        """
+        f"""
         select
            PLANE_MODEL,
            SEATING_CAPACITY
         from
-            PLANE_MODEL_ATTRIBUTES
+            {database}.{schema}.PLANE_MODEL_ATTRIBUTES
         """
     )
 

snowflake/ml/feature_store/examples/airline_features/features/weather_features.py

@@ -6,10 +6,12 @@ from snowflake.snowpark import DataFrame, Session
 
 
 # This function will be invoked by example_helper.py. Do not change the name.
-def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], source_tables: List[str]) -> FeatureView:
+def create_draft_feature_view(
+    session: Session, source_dfs: List[DataFrame], source_tables: List[str], database: str, schema: str
+) -> FeatureView:
     """Create a feature view about airport weather."""
     query = session.sql(
-        """
+        f"""
         select
             DATETIME_UTC AS TS,
             AIRPORT_ZIP_CODE,
@@ -21,9 +23,9 @@ def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], sou
             sum(RAIN_MM_H) over (
                 partition by AIRPORT_ZIP_CODE
                 order by DATETIME_UTC
-                range between interval '1 day' preceding and current row
+                range between interval '60 minutes' preceding and current row
             ) RAIN_SUM_60M
-        from AIRPORT_WEATHER_STATION
+        from {database}.{schema}.AIRPORT_WEATHER_STATION
         """
     )
 
@@ -37,6 +39,6 @@ def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], sou
     ).attach_feature_desc(
         {
             "RAIN_SUM_30M": "The sum of rain fall over past 30 minutes for one zipcode.",
-            "RAIN_SUM_60M": "The sum of rain fall over past 1 day for one zipcode.",
+            "RAIN_SUM_60M": "The sum of rain fall over past 1 hour for one zipcode.",
         }
     )

snowflake/ml/feature_store/examples/citibike_trip_features/features/station_feature.py

@@ -8,7 +8,9 @@ from snowflake.snowpark import DataFrame, Session
 
 
 # This function will be invoked by example_helper.py. Do not change the name.
-def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], source_tables: List[str]) -> FeatureView:
+def create_draft_feature_view(
+    session: Session, source_dfs: List[DataFrame], source_tables: List[str], database: str, schema: str
+) -> FeatureView:
     """Create a feature view about trip station."""
     query = session.sql(
         f"""
@@ -17,7 +19,7 @@ def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], sou
             count(end_station_id) as f_count,
             avg(end_station_latitude) as f_avg_latitude,
             avg(end_station_longitude) as f_avg_longtitude
-        from {source_tables[0]}
+        from {database}.{schema}.{source_tables[0]}
         group by end_station_id
         """
     )

snowflake/ml/feature_store/examples/citibike_trip_features/features/trip_feature.py

@@ -6,7 +6,9 @@ from snowflake.snowpark import DataFrame, Session, functions as F
 
 
 # This function will be invoked by example_helper.py. Do not change the name.
-def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], source_tables: List[str]) -> FeatureView:
+def create_draft_feature_view(
+    session: Session, source_dfs: List[DataFrame], source_tables: List[str], database: str, schema: str
+) -> FeatureView:
     """Create a feature view about trip."""
     feature_df = source_dfs[0].select(
         "trip_id",

snowflake/ml/feature_store/examples/example_helper.py

@@ -66,7 +66,9 @@ class ExampleHelper:
                 continue
             mod_path = f"{__package__}.{self._selected_example}.features.{f_name.rstrip('.py')}"
             mod = importlib.import_module(mod_path)
-            fv = mod.create_draft_feature_view(self._session, self._source_dfs, self._source_tables)
+            fv = mod.create_draft_feature_view(
+                self._session, self._source_dfs, self._source_tables, self._database_name, self._dataset_schema
+            )
             fvs.append(fv)
 
         return fvs
@@ -140,7 +142,7 @@ class ExampleHelper:
             """
         ).collect()
 
-        return [destination_table]
+        return [schema_dict["destination_table_name"]]
 
     def _load_parquet(self, schema_dict: Dict[str, str], temp_stage_name: str) -> List[str]:
         regex_pattern = schema_dict["load_files_pattern"]
@@ -173,13 +175,14 @@ class ExampleHelper:
                 dest_table_name = (
                     f"{self._database_name}.{self._dataset_schema}.{schema_dict['destination_table_name']}"
                 )
+                result.append(schema_dict["destination_table_name"])
             else:
                 regex_pattern = schema_dict["destination_table_name"]
                 dest_table_name = re.match(regex_pattern, file_name).group("table_name")  # type: ignore[union-attr]
+                result.append(dest_table_name)
                 dest_table_name = f"{self._database_name}.{self._dataset_schema}.{dest_table_name}"
 
             df.write.mode("overwrite").save_as_table(dest_table_name)
-            result.append(dest_table_name)
 
         return result
 

snowflake/ml/feature_store/examples/new_york_taxi_features/features/location_features.py

@@ -8,7 +8,9 @@ from snowflake.snowpark import DataFrame, Session
 
 
 # This function will be invoked by example_helper.py. Do not change the name.
-def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], source_tables: List[str]) -> FeatureView:
+def create_draft_feature_view(
+    session: Session, source_dfs: List[DataFrame], source_tables: List[str], database: str, schema: str
+) -> FeatureView:
     """Create a draft feature view."""
     feature_df = session.sql(
         f"""
@@ -25,7 +27,7 @@ def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], sou
                 order by TPEP_DROPOFF_DATETIME
                 range between interval '10 hours' preceding and current row
             ) AVG_FARE_10h
-        from {source_tables[0]}
+        from {database}.{schema}.{source_tables[0]}
     """
     )
 

snowflake/ml/feature_store/examples/new_york_taxi_features/features/trip_features.py

@@ -6,7 +6,9 @@ from snowflake.snowpark import DataFrame, Session
 
 
 # This function will be invoked by example_helper.py. Do not change the name.
-def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], source_tables: List[str]) -> FeatureView:
+def create_draft_feature_view(
+    session: Session, source_dfs: List[DataFrame], source_tables: List[str], database: str, schema: str
+) -> FeatureView:
     """Create a draft feature view."""
     feature_df = session.sql(
         f"""
@@ -16,7 +18,7 @@ def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], sou
             TRIP_DISTANCE,
             FARE_AMOUNT
         from
-            {source_tables[0]}
+            {database}.{schema}.{source_tables[0]}
         """
     )
 

snowflake/ml/feature_store/examples/wine_quality_features/features/managed_wine_features.py

@@ -6,7 +6,9 @@ from snowflake.snowpark import DataFrame, Session, functions as F
 
 
 # This function will be invoked by example_helper.py. Do not change the name.
-def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], source_tables: List[str]) -> FeatureView:
+def create_draft_feature_view(
+    session: Session, source_dfs: List[DataFrame], source_tables: List[str], database: str, schema: str
+) -> FeatureView:
     """Create a feature view about trip station."""
     feature_df = source_dfs[0].select(
         "WINE_ID",

snowflake/ml/feature_store/examples/wine_quality_features/features/static_wine_features.py

@@ -6,7 +6,9 @@ from snowflake.snowpark import DataFrame, Session
 
 
 # This function will be invoked by example_helper.py. Do not change the name.
-def create_draft_feature_view(session: Session, source_dfs: List[DataFrame], source_tables: List[str]) -> FeatureView:
+def create_draft_feature_view(
+    session: Session, source_dfs: List[DataFrame], source_tables: List[str], database: str, schema: str
+) -> FeatureView:
     """Create a feature view about trip station."""
     feature_df = source_dfs[0].select("WINE_ID", "SULPHATES", "ALCOHOL")
 

snowflake/ml/feature_store/feature_store.py

@@ -1886,8 +1886,7 @@ class FeatureStore:
         if found_dts[0]["refresh_mode"] != "INCREMENTAL":
             warnings.warn(
                 "Your pipeline won't be incrementally refreshed due to: "
-                + f"\"{found_dts[0]['refresh_mode_reason']}\". "
-                + "It will likely incurr higher cost.",
+                + f"\"{found_dts[0]['refresh_mode_reason']}\".",
                 stacklevel=2,
                 category=UserWarning,
             )

snowflake/ml/feature_store/feature_view.py

@@ -169,6 +169,7 @@ class FeatureView(lineage_node.LineageNode):
         desc: str = "",
         warehouse: Optional[str] = None,
         initialize: str = "ON_CREATE",
+        refresh_mode: str = "AUTO",
         **_kwargs: Any,
     ) -> None:
         """
@@ -196,6 +197,9 @@ class FeatureView(lineage_node.LineageNode):
                 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.
+            refresh_mode: The refresh mode of managed feature view. The value can be 'AUTO', 'FULL' or 'INCREMENETAL'.
+                For managed feature view, the default value is 'AUTO'. For static feature view it has no effect.
+                Check https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table for for details.
             _kwargs: reserved kwargs for system generated args. NOTE: DO NOT USE.
 
         Example::
@@ -242,7 +246,7 @@ class FeatureView(lineage_node.LineageNode):
         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: Optional[str] = refresh_mode
         self._refresh_mode_reason: Optional[str] = None
         self._owner: Optional[str] = None
         self._validate()