snowflake-ml-python 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

snowflake/ml/_internal/utils/identifier.py

@@ -23,7 +23,7 @@ quote_name_without_upper_casing = analyzer_utils.quote_name_without_upper_casing
 
 
 def _is_quoted(id: str) -> bool:
-    """Checks if input is quoted.
+    """Checks if input *identifier* is quoted.
 
     NOTE: Snowflake treats all identifiers as UPPERCASE by default. That is 'Hello' would become 'HELLO'. To preserve
     case, one needs to use quoted identifiers, e.g. "Hello" (note the double quote). Callers must take care of that
@@ -40,23 +40,21 @@ def _is_quoted(id: str) -> bool:
         ValueError: If the id is invalid.
     """
     if not id:
-        raise ValueError("Invalid id passed.")
-    if len(id) < 2:
-        return False
-    if id[0] == '"' and id[-1] == '"':
+        raise ValueError(f"Invalid id {id} passed. ID is empty.")
+    if len(id) >= 2 and id[0] == '"' and id[-1] == '"':
         if len(id) == 2:
-            raise ValueError("Invalid id passed.")
+            raise ValueError(f"Invalid id {id} passed. ID is empty.")
         if not QUOTED_IDENTIFIER_RE.match(id):
-            raise ValueError("Invalid id passed.")
+            raise ValueError(f"Invalid id {id} passed. ID is quoted but does not match the quoted rule.")
         return True
-    if not UNQUOTED_CASE_INSENSITIVE_RE.match(id):
-        raise ValueError("Invalid id passed.")
-    return False  # To keep mypy happy
+    if not UNQUOTED_CASE_SENSITIVE_RE.match(id):
+        raise ValueError(f"Invalid id {id} passed. ID is unquoted but does not match the unquoted rule.")
+    return False
 
 
 def _get_unescaped_name(id: str) -> str:
     """Remove double quotes and unescape quotes between them from id if quoted.
-        Uppercase if not quoted.
+        Return as it is otherwise
 
     NOTE: See note in :meth:`_is_quoted`.
 
@@ -67,7 +65,7 @@ def _get_unescaped_name(id: str) -> str:
         String with quotes removed if quoted; original string otherwise.
     """
     if not _is_quoted(id):
-        return id.upper()
+        return id
     unquoted_id = id[1:-1]
     return unquoted_id.replace(DOUBLE_QUOTE + DOUBLE_QUOTE, DOUBLE_QUOTE)
 
@@ -88,9 +86,9 @@ def _get_escaped_name(id: str) -> str:
     return DOUBLE_QUOTE + escape_quotes + DOUBLE_QUOTE
 
 
-def get_inferred_name(id: str) -> str:
-    """Double quote id when it is case-sensitive and can start with and
-    contain any valid characters; unquote otherwise.
+def get_inferred_name(name: str) -> str:
+    """Double quote name when it is case-sensitive and can start with and
+    contain any valid characters; otherwise, keep it as it is.
 
     Examples:
         COL1 -> COL1
@@ -100,42 +98,38 @@ def get_inferred_name(id: str) -> str:
         COL 1 -> "COL 1"
 
     Args:
-        id: The string to be checked & treated.
+        name: The string to be checked & treated.
 
     Returns:
         Double quoted identifier if necessary; unquoted string otherwise.
     """
-    if UNQUOTED_CASE_SENSITIVE_RE.match(id):
-        return id
-    escaped_id = get_escaped_names(id)
+    if UNQUOTED_CASE_SENSITIVE_RE.match(name):
+        return name
+    escaped_id = _get_escaped_name(name)
     assert isinstance(escaped_id, str)
     return escaped_id
 
 
-def concat_names(ids: List[str]) -> str:
-    """Concatenates `ids` to form one valid id.
+def concat_names(names: List[str]) -> str:
+    """Concatenates `names` to form one valid id.
 
-    NOTE: See note in :meth:`_is_quoted`.
 
     Args:
-        ids: List of identifiers to be concatenated.
+        names: List of identifiers to be concatenated.
 
     Returns:
         Concatenated identifier.
     """
-    quotes_needed = False
     parts = []
-    for id in ids:
-        if _is_quoted(id):
-            # If any part is quoted, the user cares about case.
-            quotes_needed = True
-            # Remove quotes before using it.
-            id = _get_unescaped_name(id)
-        parts.append(id)
+    for name in names:
+        if QUOTED_IDENTIFIER_RE.match(name):
+            # If any part is quoted identifier, we need to remove the quotes
+            unescaped_name: str = _get_unescaped_name(name)
+            parts.append(unescaped_name)
+        else:
+            parts.append(name)
     final_id = "".join(parts)
-    if quotes_needed:
-        return _get_escaped_name(final_id)
-    return final_id
+    return get_inferred_name(final_id)
 
 
 def rename_to_valid_snowflake_identifier(name: str) -> str:
@@ -222,6 +216,14 @@ def get_unescaped_names(ids: Optional[Union[str, List[str]]]) -> Optional[Union[
     response pandas dataframe(i.e., in the response of snowpark_df.to_pandas()) using the rules defined here
     https://docs.snowflake.com/en/sql-reference/identifiers-syntax.
 
+    This function will mimic the behavior of Snowpark's `to_pandas()` from Snowpark DataFrame.
+
+    Examples:
+        COL1 -> COL1
+        "Col" -> Col
+        \"""COL""\" -> "COL"  (ignore '\')
+        "COL 1" -> COL 1
+
     Args:
         ids: User provided column name identifier(s).
 
@@ -243,27 +245,36 @@ def get_unescaped_names(ids: Optional[Union[str, List[str]]]) -> Optional[Union[
 
 
 @overload
-def get_escaped_names(ids: None) -> None:
+def get_inferred_names(names: None) -> None:
     ...
 
 
 @overload
-def get_escaped_names(ids: str) -> str:
+def get_inferred_names(names: str) -> str:
     ...
 
 
 @overload
-def get_escaped_names(ids: List[str]) -> List[str]:
+def get_inferred_names(names: List[str]) -> List[str]:
     ...
 
 
-def get_escaped_names(ids: Optional[Union[str, List[str]]]) -> Optional[Union[str, List[str]]]:
-    """Given a user provided identifier(s), this method will compute the equivalent column name identifier(s)
+def get_inferred_names(names: Optional[Union[str, List[str]]]) -> Optional[Union[str, List[str]]]:
+    """Given a user provided *string(s)*, this method will compute the equivalent column name identifier(s)
     in case of column name contains special characters, and maintains case-sensitivity
     https://docs.snowflake.com/en/sql-reference/identifiers-syntax.
 
+    This function will mimic the behavior of Snowpark's `create_dataframe` from pandas DataFrame.
+
+    Examples:
+        COL1 -> COL1
+        1COL -> "1COL"
+        Col -> "Col"
+        "COL" -> \"""COL""\"  (ignore '\')
+        COL 1 -> "COL 1"
+
     Args:
-        ids: User provided column name identifier(s).
+        names: User provided column name identifier(s).
 
     Returns:
         Double-quoted Identifiers for column names, to make sure that column names are case sensitive
@@ -272,12 +283,12 @@ def get_escaped_names(ids: Optional[Union[str, List[str]]]) -> Optional[Union[st
         ValueError: if input types is unsupported or column name identifiers are invalid.
     """
 
-    if ids is None:
+    if names is None:
         return None
-    elif type(ids) is list:
-        return [_get_escaped_name(id) for id in ids]
-    elif type(ids) is str:
-        return _get_escaped_name(ids)
+    elif type(names) is list:
+        return [get_inferred_name(id) for id in names]
+    elif type(names) is str:
+        return get_inferred_name(names)
     else:
         raise ValueError("Unsupported type. Only string or list of string are supported for selecting columns.")
 
@@ -297,39 +308,34 @@ def remove_prefix(s: str, prefix: str) -> str:
     return s
 
 
-def resolve_identifier(id: str) -> str:
-    """Following Snowflake identifier resolution strategies:
+def resolve_identifier(name: str) -> str:
+    """Given a user provided *string*, resolve following Snowflake identifier resolution strategies:
         https://docs.snowflake.com/en/sql-reference/identifiers-syntax#label-identifier-casing
 
-        If identifier is unquoted, it will return upper case.
-        Otherwise return exactly as it is.
-
-    Args:
-        id: identifier string
-
-    Returns:
-        Resolved identifier
-    """
-    if _is_quoted(id):
-        if UNQUOTED_CASE_SENSITIVE_RE.match(id[1:-1]):
-            return id[1:-1]
-        else:
-            return id
-    else:
-        return id.upper()
-
+        This function will mimic the behavior of the SQL parser.
 
-def strip_wrapping_quotes(id: str) -> str:
-    """Remove wrapping quotes if the identifier is quoted.
-    This is mainly used for keywords like `warehouse` which doesn't like wrapping quotes when being used.
+    Examples:
+        COL1 -> COL1
+        1COL -> Raise Error
+        Col -> COL
+        "COL" -> COL
+        COL 1 -> Raise Error
 
     Args:
-        id: identifier string
+        name: the string to be resolved.
+
+    Raises:
+        ValueError: if input would not be accepted by SQL parser.
 
     Returns:
-        Identifier with wrapping quotes removed
+        Resolved identifier
     """
-    if _is_quoted(id):
-        return id[1:-1]
+    if QUOTED_IDENTIFIER_RE.match(name):
+        unescaped = _get_unescaped_name(name)
+        if UNQUOTED_CASE_SENSITIVE_RE.match(unescaped):
+            return unescaped
+        return name
+    elif UNQUOTED_CASE_INSENSITIVE_RE.match(name):
+        return name.upper()
     else:
-        return id
+        raise ValueError(f"Invalid name {name} passed. ID is not quoted and cannot normalized.")

snowflake/ml/_internal/utils/retryable_http.py

@@ -5,11 +5,23 @@ from requests import adapters
 from urllib3.util import retry
 
 
-def get_http_client() -> requests.Session:
-    # Set up a retry policy for requests
+def get_http_client(total_retries: int = 5, backoff_factor: float = 0.1) -> requests.Session:
+    """Construct retryable http client.
+
+    Args:
+        total_retries: Total number of retries to allow.
+        backoff_factor: A backoff factor to apply between attempts after the second try. Time to sleep is calculated by
+            {backoff factor} * (2 ** ({number of previous retries})). For example, with default retries of 5 and backoff
+            factor set to 0.1, each subsequent retry will sleep [0.2s, 0.4s, 0.8s, 1.6s, 3.2s] respectively.
+
+    Returns:
+        requests.Session object.
+
+    """
+
     retry_strategy = retry.Retry(
-        total=3,  # total number of retries
-        backoff_factor=0.1,  # 100ms initial delay
+        total=total_retries,
+        backoff_factor=backoff_factor,
         status_forcelist=[
             http.HTTPStatus.TOO_MANY_REQUESTS,
             http.HTTPStatus.INTERNAL_SERVER_ERROR,

snowflake/ml/_internal/utils/spcs_attribution_utils.py

@@ -0,0 +1,122 @@
+import logging
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from snowflake import snowpark
+from snowflake.ml._internal import telemetry
+from snowflake.ml._internal.utils import query_result_checker
+
+logger = logging.getLogger(__name__)
+
+_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S.%f %z"
+_COMPUTE_POOL = "compute_pool"
+_CREATED_ON = "created_on"
+_INSTANCE_FAMILY = "instance_family"
+_NAME = "name"
+_TELEMETRY_PROJECT = "MLOps"
+_TELEMETRY_SUBPROJECT = "SpcsDeployment"
+_SERVICE_START = "SPCS_SERVICE_START"
+_SERVICE_END = "SPCS_SERVICE_END"
+
+
+def _desc_compute_pool(session: snowpark.Session, compute_pool_name: str) -> Dict[str, Any]:
+    sql = f"DESC COMPUTE POOL {compute_pool_name}"
+    result = (
+        query_result_checker.SqlResultValidator(
+            session=session,
+            query=sql,
+        )
+        .has_column(_INSTANCE_FAMILY)
+        .has_column(_NAME)
+        .has_dimensions(expected_rows=1)
+        .validate()
+    )
+    return result[0].as_dict()
+
+
+def _desc_service(session: snowpark.Session, fully_qualified_name: str) -> Dict[str, Any]:
+    sql = f"DESC SERVICE {fully_qualified_name}"
+    result = (
+        query_result_checker.SqlResultValidator(
+            session=session,
+            query=sql,
+        )
+        .has_column(_COMPUTE_POOL)
+        .has_dimensions(expected_rows=1)
+        .validate()
+    )
+    return result[0].as_dict()
+
+
+def _get_current_time() -> datetime:
+    """
+    This method exists to make it easier to mock datetime in test.
+
+    Returns:
+        current datetime
+    """
+    return datetime.now()
+
+
+def _send_service_telemetry(
+    fully_qualified_name: Optional[str] = None,
+    compute_pool_name: Optional[str] = None,
+    service_details: Optional[Dict[str, Any]] = None,
+    compute_pool_details: Optional[Dict[str, Any]] = None,
+    duration_in_seconds: Optional[int] = None,
+    kwargs: Optional[Dict[str, Any]] = None,
+) -> None:
+    try:
+        telemetry.send_custom_usage(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+            telemetry_type=telemetry.TelemetryField.TYPE_SNOWML_SPCS_USAGE.value,
+            data={
+                "service_name": fully_qualified_name,
+                "compute_pool_name": compute_pool_name,
+                "service_details": service_details,
+                "compute_pool_details": compute_pool_details,
+                "duration_in_seconds": duration_in_seconds,
+            },
+            kwargs=kwargs,
+        )
+    except Exception as e:
+        logger.error(f"Failed to send service telemetry: {e}")
+
+
+def record_service_start(session: snowpark.Session, fully_qualified_name: str) -> None:
+    service_details = _desc_service(session, fully_qualified_name)
+    compute_pool_name = service_details[_COMPUTE_POOL]
+    compute_pool_details = _desc_compute_pool(session, compute_pool_name)
+
+    _send_service_telemetry(
+        fully_qualified_name=fully_qualified_name,
+        compute_pool_name=compute_pool_name,
+        service_details=service_details,
+        compute_pool_details=compute_pool_details,
+        kwargs={telemetry.TelemetryField.KEY_CUSTOM_TAGS.value: _SERVICE_START},
+    )
+
+    logger.info(f"Service {fully_qualified_name} created with compute pool {compute_pool_name}.")
+
+
+def record_service_end(session: snowpark.Session, fully_qualified_name: str) -> None:
+    service_details = _desc_service(session, fully_qualified_name)
+    compute_pool_details = _desc_compute_pool(session, service_details[_COMPUTE_POOL])
+    compute_pool_name = service_details[_COMPUTE_POOL]
+
+    created_on_datetime: datetime = service_details[_CREATED_ON]
+    current_time: datetime = _get_current_time()
+    current_time = current_time.replace(tzinfo=created_on_datetime.tzinfo)
+    duration_in_seconds = int((current_time - created_on_datetime).total_seconds())
+
+    _send_service_telemetry(
+        fully_qualified_name=fully_qualified_name,
+        compute_pool_name=compute_pool_name,
+        service_details=service_details,
+        compute_pool_details=compute_pool_details,
+        duration_in_seconds=duration_in_seconds,
+        kwargs={telemetry.TelemetryField.KEY_CUSTOM_TAGS.value: _SERVICE_END},
+    )
+
+    logger.info(f"Service {fully_qualified_name} deleted from compute pool {compute_pool_name}")

snowflake/ml/dataset/dataset.py

@@ -140,7 +140,7 @@ Got {len(self.df.queries['queries'])}: {self.df.queries['queries']}
 
     @classmethod
     def from_json(cls, json_str: str, session: Session) -> "Dataset":
-        json_dict = json.loads(json_str)
+        json_dict = json.loads(json_str, strict=False)
         json_dict["df"] = session.sql(json_dict.pop("df_query"))
 
         fs_meta_json = json_dict["feature_store_metadata"]

snowflake/ml/model/_api.py

@@ -7,7 +7,6 @@ from snowflake.ml._internal.exceptions import (
     error_codes,
     exceptions as snowml_exceptions,
 )
-from snowflake.ml._internal.utils import identifier
 from snowflake.ml.model import (
     deploy_platforms,
     model_signature,
@@ -188,6 +187,10 @@ def save_model(
     Returns:
         Model
     """
+    if options is None:
+        options = {}
+    options["_legacy_save"] = True
+
     m = model_composer.ModelComposer(session=session, stage_path=stage_path)
     m.save(
         name=name,
@@ -481,6 +484,7 @@ def predict(
     # Get options
     INTERMEDIATE_OBJ_NAME = "tmp_result"
     sig = deployment["signature"]
+    identifier_rule = model_signature.SnowparkIdentifierRule.INFERRED
 
     # Validate and prepare input
     if not isinstance(X, SnowparkDataFrame):
@@ -491,7 +495,7 @@ def predict(
     else:
         keep_order = False
         output_with_input_features = True
-        model_signature._validate_snowpark_data(X, sig.inputs)
+        identifier_rule = model_signature._validate_snowpark_data(X, sig.inputs)
         s_df = X
 
     if statement_params:
@@ -500,10 +504,14 @@ def predict(
         else:
             s_df._statement_params = statement_params  # type: ignore[assignment]
 
+    original_cols = s_df.columns
+
     # Infer and get intermediate result
     input_cols = []
-    for col_name in s_df.columns:
-        literal_col_name = identifier.get_unescaped_names(col_name)
+    for input_feature in sig.inputs:
+        literal_col_name = input_feature.name
+        col_name = identifier_rule.get_identifier_from_feature(input_feature.name)
+
         input_cols.extend(
             [
                 F.lit(literal_col_name),
@@ -511,29 +519,28 @@ def predict(
             ]
         )
 
-    # TODO[shchen]: SNOW-870032, For SnowService, external function name cannot be double quoted, else it results in
-    # external function no found.
     udf_name = deployment["name"]
-    output_obj = F.call_udf(udf_name, F.object_construct(*input_cols))
-
-    if output_with_input_features:
-        df_res = s_df.with_column(INTERMEDIATE_OBJ_NAME, output_obj)
-    else:
-        df_res = s_df.select(output_obj.alias(INTERMEDIATE_OBJ_NAME))
+    output_obj = F.call_udf(udf_name, F.object_construct_keep_null(*input_cols))
+    df_res = s_df.with_column(INTERMEDIATE_OBJ_NAME, output_obj)
 
     if keep_order:
         df_res = df_res.order_by(
-            F.col(INTERMEDIATE_OBJ_NAME)[infer_template._KEEP_ORDER_COL_NAME],
+            F.col(infer_template._KEEP_ORDER_COL_NAME),
             ascending=True,
         )
 
+    if not output_with_input_features:
+        df_res = df_res.drop(*original_cols)
+
     # Prepare the output
     output_cols = []
+    output_col_names = []
     for output_feature in sig.outputs:
         output_cols.append(F.col(INTERMEDIATE_OBJ_NAME)[output_feature.name].astype(output_feature.as_snowpark_type()))
+        output_col_names.append(identifier_rule.get_identifier_from_feature(output_feature.name))
 
     df_res = df_res.with_columns(
-        [identifier.get_inferred_name(output_feature.name) for output_feature in sig.outputs],
+        output_col_names,
         output_cols,
     ).drop(INTERMEDIATE_OBJ_NAME)
 

snowflake/ml/model/_client/model/model_impl.py

@@ -0,0 +1,176 @@
+from typing import List, Union
+
+from snowflake.ml._internal import telemetry
+from snowflake.ml._internal.utils import sql_identifier
+from snowflake.ml.model._client.model import model_version_impl
+from snowflake.ml.model._client.ops import model_ops
+
+_TELEMETRY_PROJECT = "MLOps"
+_TELEMETRY_SUBPROJECT = "ModelManagement"
+
+
+class Model:
+    """Model Object containing multiple versions. Mapping to SQL's MODEL object."""
+
+    _model_ops: model_ops.ModelOperator
+    _model_name: sql_identifier.SqlIdentifier
+
+    def __init__(self) -> None:
+        raise RuntimeError("Model's initializer is not meant to be used. Use `get_model` from registry instead.")
+
+    @classmethod
+    def _ref(
+        cls,
+        model_ops: model_ops.ModelOperator,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+    ) -> "Model":
+        self: "Model" = object.__new__(cls)
+        self._model_ops = model_ops
+        self._model_name = model_name
+        return self
+
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, Model):
+            return False
+        return self._model_ops == __value._model_ops and self._model_name == __value._model_name
+
+    @property
+    def name(self) -> str:
+        return self._model_name.identifier()
+
+    @property
+    def fully_qualified_name(self) -> str:
+        return self._model_ops._model_version_client.fully_qualified_model_name(self._model_name)
+
+    @property
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def description(self) -> str:
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        return self._model_ops.get_comment(
+            model_name=self._model_name,
+            statement_params=statement_params,
+        )
+
+    @description.setter
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def description(self, description: str) -> None:
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        return self._model_ops.set_comment(
+            comment=description,
+            model_name=self._model_name,
+            statement_params=statement_params,
+        )
+
+    @property
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def default(self) -> model_version_impl.ModelVersion:
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+            class_name=self.__class__.__name__,
+        )
+        default_version_name = self._model_ops._model_version_client.get_default_version(
+            model_name=self._model_name, statement_params=statement_params
+        )
+        return self.version(default_version_name)
+
+    @default.setter
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def default(self, version: Union[str, model_version_impl.ModelVersion]) -> None:
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+            class_name=self.__class__.__name__,
+        )
+        if isinstance(version, str):
+            version_name = sql_identifier.SqlIdentifier(version)
+        else:
+            version_name = version._version_name
+        self._model_ops._model_version_client.set_default_version(
+            model_name=self._model_name, version_name=version_name, statement_params=statement_params
+        )
+
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def version(self, version_name: str) -> model_version_impl.ModelVersion:
+        """Get a model version object given a version name in the model.
+
+        Args:
+            version_name: The name of version
+
+        Raises:
+            ValueError: Raised when the version requested does not exist.
+
+        Returns:
+            The model version object.
+        """
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        version_id = sql_identifier.SqlIdentifier(version_name)
+        if self._model_ops.validate_existence(
+            model_name=self._model_name,
+            version_name=version_id,
+            statement_params=statement_params,
+        ):
+            return model_version_impl.ModelVersion._ref(
+                self._model_ops,
+                model_name=self._model_name,
+                version_name=version_id,
+            )
+        else:
+            raise ValueError(
+                f"Unable to find version with name {version_id.identifier()} in model {self.fully_qualified_name}"
+            )
+
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def list_versions(self) -> List[model_version_impl.ModelVersion]:
+        """List all versions in the model.
+
+        Returns:
+            A List of ModelVersion object representing all versions in the model.
+        """
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        version_names = self._model_ops.list_models_or_versions(
+            model_name=self._model_name,
+            statement_params=statement_params,
+        )
+        return [
+            model_version_impl.ModelVersion._ref(
+                self._model_ops,
+                model_name=self._model_name,
+                version_name=version_name,
+            )
+            for version_name in version_names
+        ]
+
+    def delete_version(self, version_name: str) -> None:
+        raise NotImplementedError("Deleting version has not been supported yet.")