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

snowflake/ml/{model/_deploy_client/utils → _internal/container_services/image_registry}/imagelib.py

@@ -23,7 +23,9 @@ from typing import Dict, List, Optional, Tuple
 
 import requests
 
-from snowflake.ml._internal.utils import image_registry_http_client
+from snowflake.ml._internal.container_services.image_registry import (
+    http_client as image_registry_http_client,
+)
 
 # Common HTTP headers
 _CONTENT_LENGTH_HEADER = "content-length"

snowflake/ml/{model/_deploy_client/utils/image_registry_client.py → _internal/container_services/image_registry/registry_client.py}

@@ -3,12 +3,14 @@ import logging
 from typing import Dict, Optional, cast
 from urllib.parse import urlunparse
 
+from snowflake.ml._internal.container_services.image_registry import (
+    http_client as image_registry_http_client,
+    imagelib,
+)
 from snowflake.ml._internal.exceptions import (
     error_codes,
     exceptions as snowml_exceptions,
 )
-from snowflake.ml._internal.utils import image_registry_http_client
-from snowflake.ml.model._deploy_client.utils import imagelib
 from snowflake.snowpark import Session
 from snowflake.snowpark._internal import utils as snowpark_utils
 

snowflake/ml/_internal/env_utils.py

@@ -33,7 +33,6 @@ class CONDA_OS(Enum):
 
 _SNOWFLAKE_CONDA_CHANNEL_URL = "https://repo.anaconda.com/pkgs/snowflake"
 _NODEFAULTS = "nodefaults"
-_INFO_SCHEMA_PACKAGES_HAS_RUNTIME_VERSION: Optional[bool] = None
 _SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE: Dict[str, List[version.Version]] = {}
 _SNOWFLAKE_CONDA_PACKAGE_CACHE: Dict[str, List[version.Version]] = {}
 
@@ -267,18 +266,6 @@ def relax_requirement_version(req: requirements.Requirement) -> requirements.Req
     return new_req
 
 
-def _check_runtime_version_column_existence(session: session.Session) -> bool:
-    sql = textwrap.dedent(
-        """
-        SHOW COLUMNS
-        LIKE 'runtime_version'
-        IN TABLE information_schema.packages;
-        """
-    )
-    result = session.sql(sql).count()
-    return result == 1
-
-
 def get_matched_package_versions_in_snowflake_conda_channel(
     req: requirements.Requirement,
     python_version: str = snowml_env.PYTHON_VERSION,
@@ -325,9 +312,9 @@ def get_matched_package_versions_in_snowflake_conda_channel(
     return matched_versions
 
 
-def validate_requirements_in_information_schema(
+def get_matched_package_versions_in_information_schema(
     session: session.Session, reqs: List[requirements.Requirement], python_version: str
-) -> Optional[List[str]]:
+) -> Dict[str, List[version.Version]]:
     """Look up the information_schema table to check if a package with the specified specifier exists in the Snowflake
     Conda channel. Note that this is not the source of truth due to the potential delay caused by a package that might
     exist in the information_schema table but has not yet become available in the Snowflake Conda channel.
@@ -338,42 +325,35 @@ def validate_requirements_in_information_schema(
         python_version: A string of python version where model is run.
 
     Returns:
-        A list of pinned latest version that available in Snowflake anaconda channel and meet the version specifier.
+        A Dict, whose key is the package name, and value is a list of versions match the requirements.
     """
-    global _INFO_SCHEMA_PACKAGES_HAS_RUNTIME_VERSION
-
-    if _INFO_SCHEMA_PACKAGES_HAS_RUNTIME_VERSION is None:
-        _INFO_SCHEMA_PACKAGES_HAS_RUNTIME_VERSION = _check_runtime_version_column_existence(session)
-    ret_list = []
-    reqs_to_request = []
+    ret_dict: Dict[str, List[version.Version]] = {}
+    reqs_to_request: List[requirements.Requirement] = []
     for req in reqs:
-        if req.name not in _SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE:
+        if req.name in _SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE:
+            available_versions = list(
+                sorted(req.specifier.filter(set(_SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE.get(req.name, []))))
+            )
+            ret_dict[req.name] = available_versions
+        else:
             reqs_to_request.append(req)
+
     if reqs_to_request:
         pkg_names_str = " OR ".join(
             f"package_name = '{req_name}'" for req_name in sorted(req.name for req in reqs_to_request)
         )
-        if _INFO_SCHEMA_PACKAGES_HAS_RUNTIME_VERSION:
-            parsed_python_version = version.Version(python_version)
-            sql = textwrap.dedent(
-                f"""
-                SELECT PACKAGE_NAME, VERSION
-                FROM information_schema.packages
-                WHERE ({pkg_names_str})
-                AND language = 'python'
-                AND (runtime_version = '{parsed_python_version.major}.{parsed_python_version.minor}'
-                    OR runtime_version is null);
-                """
-            )
-        else:
-            sql = textwrap.dedent(
-                f"""
-                SELECT PACKAGE_NAME, VERSION
-                FROM information_schema.packages
-                WHERE ({pkg_names_str})
-                AND language = 'python';
-                """
-            )
+
+        parsed_python_version = version.Version(python_version)
+        sql = textwrap.dedent(
+            f"""
+            SELECT PACKAGE_NAME, VERSION
+            FROM information_schema.packages
+            WHERE ({pkg_names_str})
+            AND language = 'python'
+            AND (runtime_version = '{parsed_python_version.major}.{parsed_python_version.minor}'
+                OR runtime_version is null);
+            """
+        )
 
         try:
             result = (
@@ -392,14 +372,13 @@ def validate_requirements_in_information_schema(
                 cached_req_ver_list.append(req_ver)
                 _SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE[req_name] = cached_req_ver_list
         except snowflake.connector.DataError:
-            return None
-    for req in reqs:
-        available_versions = list(req.specifier.filter(set(_SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE.get(req.name, []))))
-        if not available_versions:
-            return None
-        else:
-            ret_list.append(str(req))
-    return sorted(ret_list)
+            return ret_dict
+    for req in reqs_to_request:
+        available_versions = list(
+            sorted(req.specifier.filter(set(_SNOWFLAKE_INFO_SCHEMA_PACKAGE_CACHE.get(req.name, []))))
+        )
+        ret_dict[req.name] = available_versions
+    return ret_dict
 
 
 def save_conda_env_file(

snowflake/ml/_internal/file_utils.py

@@ -362,3 +362,20 @@ def download_directory_from_stage(
             wait_exponential_multiplier=100,
             wait_exponential_max=10000,
         )(file_operation.get)(str(stage_file_path), str(local_file_dir), statement_params=statement_params)
+
+
+def open_file(path: str, *args: Any, **kwargs: Any) -> Any:
+    """This function is a wrapper on top of the Python built-in "open" function, with a few added default values
+    to ensure successful execution across different platforms.
+
+    Args:
+        path: file path
+        *args: arguments.
+        **kwargs: key arguments.
+
+    Returns:
+        Open file and return a stream.
+    """
+    kwargs.setdefault("newline", "\n")
+    kwargs.setdefault("encoding", "utf-8")
+    return open(path, *args, **kwargs)

snowflake/ml/_internal/telemetry.py

@@ -584,3 +584,22 @@ class _SourceTelemetryClient:
         """Send the telemetry data batch immediately."""
         if self._telemetry:
             self._telemetry.send_batch()
+
+
+def get_sproc_statement_params_kwargs(sproc: Callable[..., Any], statement_params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get statement_params keyword argument for sproc call.
+
+    Args:
+        sproc: sproc function
+        statement_params: dictionary to be passed as statement params, if possible
+
+    Returns:
+        Keyword arguments dict
+    """
+    sproc_argspec = inspect.getfullargspec(sproc)
+    kwargs = {}
+    if "statement_params" in sproc_argspec.args:
+        kwargs["statement_params"] = statement_params
+
+    return kwargs

snowflake/ml/_internal/utils/query_result_checker.py

@@ -60,9 +60,13 @@ def result_dimension_matcher(
     return True
 
 
-def column_name_matcher(expected_col_name: str, result: list[snowpark.Row], sql: str | None = None) -> bool:
+def column_name_matcher(
+    expected_col_name: str, allow_empty: bool, result: list[snowpark.Row], sql: str | None = None
+) -> bool:
     """Returns true if `expected_col_name` is found. Raise exception otherwise."""
     if not result:
+        if allow_empty:
+            return True
         raise connector.DataError(f"Query Result is empty.{_query_log(sql)}")
     if expected_col_name not in result[0]:
         raise connector.DataError(
@@ -159,16 +163,17 @@ class ResultValidator:
         self._success_matchers.append(partial(result_dimension_matcher, expected_rows, expected_cols))
         return self
 
-    def has_column(self, expected_col_name: str) -> ResultValidator:
+    def has_column(self, expected_col_name: str, allow_empty: bool = False) -> ResultValidator:
         """Validate that the a column with the name `expected_column_name` exists in the result.
 
         Args:
             expected_col_name: Name of the column that is expected to be present in the result (case sensitive).
+            allow_empty: If the check will fail if the result is empty.
 
         Returns:
             ResultValidator object (self)
         """
-        self._success_matchers.append(partial(column_name_matcher, expected_col_name))
+        self._success_matchers.append(partial(column_name_matcher, expected_col_name, allow_empty))
         return self
 
     def has_named_value_match(self, row_idx: int, col_name: str, expected_value: Any) -> ResultValidator:
@@ -224,8 +229,6 @@ class ResultValidator:
         Returns:
             Query result.
         """
-        if len(self._success_matchers) == 0:
-            self._success_matchers = _DEFAULT_MATCHERS
         result = self._get_result()
         for matcher in self._success_matchers:
             assert matcher(result, self._query)

snowflake/ml/_internal/utils/snowflake_env.py

@@ -0,0 +1,95 @@
+import enum
+from typing import Any, Dict, Optional, TypedDict, cast
+
+from packaging import version
+from typing_extensions import Required
+
+from snowflake.ml._internal.utils import query_result_checker
+from snowflake.snowpark import session
+
+
+def get_current_snowflake_version(
+    sess: session.Session, *, statement_params: Optional[Dict[str, Any]] = None
+) -> version.Version:
+    """Get Snowflake Version as a version.Version object follow PEP way of versioning, that is to say:
+        "7.44.2 b202312132139364eb71238" to <Version('7.44.2+b202312132139364eb71238')>
+
+    Args:
+        sess: Snowpark Session.
+        statement_params: Statement params. Defaults to None.
+
+    Returns:
+        The version of Snowflake Version.
+    """
+    res = (
+        query_result_checker.SqlResultValidator(
+            sess, "SELECT CURRENT_VERSION() AS CURRENT_VERSION", statement_params=statement_params
+        )
+        .has_dimensions(expected_rows=1, expected_cols=1)
+        .validate()[0]
+    )
+
+    version_str = res.CURRENT_VERSION
+    assert isinstance(version_str, str)
+
+    version_str = "+".join(version_str.split())
+    return version.parse(version_str)
+
+
+class SnowflakeCloudType(enum.Enum):
+    AWS = "aws"
+    AZURE = "azure"
+    GCP = "gcp"
+
+    @classmethod
+    def from_value(cls, value: str) -> "SnowflakeCloudType":
+        assert value
+        for k in cls:
+            if k.value == value.lower():
+                return k
+        else:
+            raise ValueError(f"'{cls.__name__}' enum not found for '{value}'")
+
+
+class SnowflakeRegion(TypedDict):
+    region_group: Required[str]
+    snowflake_region: Required[str]
+    cloud: Required[SnowflakeCloudType]
+    region: Required[str]
+    display_name: Required[str]
+
+
+def get_regions(
+    sess: session.Session, *, statement_params: Optional[Dict[str, Any]] = None
+) -> Dict[str, SnowflakeRegion]:
+    res = (
+        query_result_checker.SqlResultValidator(sess, "SHOW REGIONS", statement_params=statement_params)
+        .has_column("region_group")
+        .has_column("snowflake_region")
+        .has_column("cloud")
+        .has_column("region")
+        .has_column("display_name")
+        .validate()
+    )
+    return {
+        f"{r.region_group}.{r.snowflake_region}": SnowflakeRegion(
+            region_group=r.region_group,
+            snowflake_region=r.snowflake_region,
+            cloud=SnowflakeCloudType.from_value(r.cloud),
+            region=r.region,
+            display_name=r.display_name,
+        )
+        for r in res
+    }
+
+
+def get_current_region_id(sess: session.Session, *, statement_params: Optional[Dict[str, Any]] = None) -> str:
+    res = (
+        query_result_checker.SqlResultValidator(
+            sess, "SELECT CURRENT_REGION() AS CURRENT_REGION", statement_params=statement_params
+        )
+        .has_dimensions(expected_rows=1, expected_cols=1)
+        .validate()[0]
+    )
+
+    return cast(str, res.CURRENT_REGION)

snowflake/ml/fileset/parquet_parser.py

@@ -1,4 +1,6 @@
 import collections
+import logging
+import time
 from typing import Any, Deque, Dict, Iterator, List
 
 import fsspec
@@ -83,7 +85,7 @@ class ParquetParser:
             np.random.shuffle(files)
         pa_dataset: ds.Dataset = ds.dataset(files, format="parquet", filesystem=self._fs)
 
-        for rb in pa_dataset.to_batches(batch_size=self._dataset_batch_size):
+        for rb in _retryable_batches(pa_dataset, batch_size=self._dataset_batch_size):
             if self._shuffle:
                 rb = rb.take(np.random.permutation(rb.num_rows))
             self._rb_buffer.append(rb)
@@ -138,3 +140,31 @@ def _record_batch_to_arrays(rb: pa.RecordBatch) -> Dict[str, npt.NDArray[Any]]:
         array = column.to_numpy(zero_copy_only=False)
         batch_dict[column_schema.name] = array
     return batch_dict
+
+
+def _retryable_batches(
+    dataset: ds.Dataset, batch_size: int, max_retries: int = 3, delay: int = 0
+) -> Iterator[pa.RecordBatch]:
+    """Make the Dataset to_batches retryable."""
+    retries = 0
+    current_batch_index = 0
+
+    while True:
+        try:
+            for batch_index, batch in enumerate(dataset.to_batches(batch_size=batch_size)):
+                if batch_index < current_batch_index:
+                    # Skip batches that have already been processed
+                    continue
+
+                yield batch
+                current_batch_index = batch_index + 1
+            # Exit the loop once all batches are processed
+            break
+
+        except Exception as e:
+            if retries < max_retries:
+                retries += 1
+                logging.info(f"Error encountered: {e}. Retrying {retries}/{max_retries}...")
+                time.sleep(delay)
+            else:
+                raise e

snowflake/ml/model/__init__.py

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

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

@@ -1,7 +1,9 @@
-from typing import List, Union
+from typing import Dict, List, Optional, Tuple, Union
+
+import pandas as pd
 
 from snowflake.ml._internal import telemetry
-from snowflake.ml._internal.utils import sql_identifier
+from snowflake.ml._internal.utils import identifier, sql_identifier
 from snowflake.ml.model._client.model import model_version_impl
 from snowflake.ml.model._client.ops import model_ops
 
@@ -37,10 +39,12 @@ class Model:
 
     @property
     def name(self) -> str:
+        """Return the name of the model that can be used to refer to it in SQL."""
         return self._model_name.identifier()
 
     @property
     def fully_qualified_name(self) -> str:
+        """Return the fully qualified name of the model that can be used to refer to it in SQL."""
         return self._model_ops._model_version_client.fully_qualified_model_name(self._model_name)
 
     @property
@@ -49,6 +53,24 @@ class Model:
         subproject=_TELEMETRY_SUBPROJECT,
     )
     def description(self) -> str:
+        """The description for the model. This is an alias of `comment`."""
+        return self.comment
+
+    @description.setter
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def description(self, description: str) -> None:
+        self.comment = description
+
+    @property
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def comment(self) -> str:
+        """The comment to the model."""
         statement_params = telemetry.get_statement_params(
             project=_TELEMETRY_PROJECT,
             subproject=_TELEMETRY_SUBPROJECT,
@@ -58,18 +80,18 @@ class Model:
             statement_params=statement_params,
         )
 
-    @description.setter
+    @comment.setter
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,
     )
-    def description(self, description: str) -> None:
+    def comment(self, comment: str) -> None:
         statement_params = telemetry.get_statement_params(
             project=_TELEMETRY_PROJECT,
             subproject=_TELEMETRY_SUBPROJECT,
         )
         return self._model_ops.set_comment(
-            comment=description,
+            comment=comment,
             model_name=self._model_name,
             statement_params=statement_params,
         )
@@ -80,12 +102,13 @@ class Model:
         subproject=_TELEMETRY_SUBPROJECT,
     )
     def default(self) -> model_version_impl.ModelVersion:
+        """The default version of the model."""
         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(
+        default_version_name = self._model_ops.get_default_version(
             model_name=self._model_name, statement_params=statement_params
         )
         return self.version(default_version_name)
@@ -105,7 +128,7 @@ class Model:
             version_name = sql_identifier.SqlIdentifier(version)
         else:
             version_name = version._version_name
-        self._model_ops._model_version_client.set_default_version(
+        self._model_ops.set_default_version(
             model_name=self._model_name, version_name=version_name, statement_params=statement_params
         )
 
@@ -114,13 +137,14 @@ class Model:
         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.
+        """
+        Get a model version object given a version name in the model.
 
         Args:
-            version_name: The name of version
+            version_name: The name of the version.
 
         Raises:
-            ValueError: Raised when the version requested does not exist.
+            ValueError: When the requested version does not exist.
 
         Returns:
             The model version object.
@@ -149,11 +173,11 @@ class Model:
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,
     )
-    def list_versions(self) -> List[model_version_impl.ModelVersion]:
-        """List all versions in the model.
+    def versions(self) -> List[model_version_impl.ModelVersion]:
+        """Get all versions in the model.
 
         Returns:
-            A List of ModelVersion object representing all versions in the model.
+            A list of ModelVersion objects representing all versions in the model.
         """
         statement_params = telemetry.get_statement_params(
             project=_TELEMETRY_PROJECT,
@@ -172,5 +196,140 @@ class Model:
             for version_name in version_names
         ]
 
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def show_versions(self) -> pd.DataFrame:
+        """Show information about all versions in the model.
+
+        Returns:
+            A Pandas DataFrame showing information about all versions in the model.
+        """
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        rows = self._model_ops.show_models_or_versions(
+            model_name=self._model_name,
+            statement_params=statement_params,
+        )
+        return pd.DataFrame([row.as_dict() for row in rows])
+
     def delete_version(self, version_name: str) -> None:
         raise NotImplementedError("Deleting version has not been supported yet.")
+
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def show_tags(self) -> Dict[str, str]:
+        """Get a dictionary showing the tag and its value attached to the model.
+
+        Returns:
+            The model version object.
+        """
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        return self._model_ops.show_tags(model_name=self._model_name, statement_params=statement_params)
+
+    def _parse_tag_name(
+        self,
+        tag_name: str,
+    ) -> Tuple[sql_identifier.SqlIdentifier, sql_identifier.SqlIdentifier, sql_identifier.SqlIdentifier]:
+        _tag_db, _tag_schema, _tag_name, _ = identifier.parse_schema_level_object_identifier(tag_name)
+        if _tag_db is None:
+            tag_db_id = self._model_ops._model_client._database_name
+        else:
+            tag_db_id = sql_identifier.SqlIdentifier(_tag_db)
+
+        if _tag_schema is None:
+            tag_schema_id = self._model_ops._model_client._schema_name
+        else:
+            tag_schema_id = sql_identifier.SqlIdentifier(_tag_schema)
+
+        if _tag_name is None:
+            raise ValueError(f"Unable parse the tag name `{tag_name}` you input.")
+
+        tag_name_id = sql_identifier.SqlIdentifier(_tag_name)
+
+        return tag_db_id, tag_schema_id, tag_name_id
+
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def get_tag(self, tag_name: str) -> Optional[str]:
+        """Get the value of a tag attached to the model.
+
+        Args:
+            tag_name: The name of the tag, can be fully qualified. If not fully qualified, the database or schema of
+                the model will be used.
+
+        Returns:
+            The tag value as a string if the tag is attached, otherwise None.
+        """
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        tag_db_id, tag_schema_id, tag_name_id = self._parse_tag_name(tag_name)
+        return self._model_ops.get_tag_value(
+            model_name=self._model_name,
+            tag_database_name=tag_db_id,
+            tag_schema_name=tag_schema_id,
+            tag_name=tag_name_id,
+            statement_params=statement_params,
+        )
+
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def set_tag(self, tag_name: str, tag_value: str) -> None:
+        """Set the value of a tag, attaching it to the model if not.
+
+        Args:
+            tag_name: The name of the tag, can be fully qualified. If not fully qualified, the database or schema of
+                the model will be used.
+            tag_value: The value of the tag
+        """
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        tag_db_id, tag_schema_id, tag_name_id = self._parse_tag_name(tag_name)
+        self._model_ops.set_tag(
+            model_name=self._model_name,
+            tag_database_name=tag_db_id,
+            tag_schema_name=tag_schema_id,
+            tag_name=tag_name_id,
+            tag_value=tag_value,
+            statement_params=statement_params,
+        )
+
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def unset_tag(self, tag_name: str) -> None:
+        """Unset a tag attached to a model.
+
+        Args:
+            tag_name: The name of the tag, 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,
+        )
+        tag_db_id, tag_schema_id, tag_name_id = self._parse_tag_name(tag_name)
+        self._model_ops.unset_tag(
+            model_name=self._model_name,
+            tag_database_name=tag_db_id,
+            tag_schema_name=tag_schema_id,
+            tag_name=tag_name_id,
+            statement_params=statement_params,
+        )