snowflake-ml-python 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

snowflake/ml/_internal/env_utils.py

@@ -310,7 +310,8 @@ def validate_requirements_in_snowflake_conda_channel(
                 FROM information_schema.packages
                 WHERE ({pkg_names_str})
                 AND language = 'python'
-                AND runtime_version = '{parsed_python_version.major}.{parsed_python_version.minor}';
+                AND (runtime_version = '{parsed_python_version.major}.{parsed_python_version.minor}'
+                    OR runtime_version is null);
                 """
             )
         else:

snowflake/ml/_internal/file_utils.py

@@ -1,15 +1,13 @@
 import contextlib
 import hashlib
-import importlib
 import io
 import os
 import pathlib
+import pkgutil
 import shutil
 import tempfile
 import zipfile
-from typing import IO, Generator, Optional, Tuple, Union
-
-from snowflake.snowpark import session as snowpark_session
+from typing import IO, Generator, List, Optional, Union
 
 GENERATED_PY_FILE_EXT = (".pyc", ".pyo", ".pyd", ".pyi")
 
@@ -61,10 +59,12 @@ def zip_file_or_directory_to_stream(
     Raises:
         FileNotFoundError: Raised when the given path does not exist.
         ValueError: Raised when the leading path is not a actual leading path of path
+        ValueError: Raised when the arcname cannot be encoded using ASCII.
 
     Yields:
         A bytes IO stream containing the zip file.
     """
+    # TODO(SNOW-862576): Should remove check on ASCII encoding after SNOW-862576 fixed.
     if not os.path.exists(path):
         raise FileNotFoundError(f"{path} is not found")
     if leading_path and not path.startswith(leading_path):
@@ -78,23 +78,35 @@ def zip_file_or_directory_to_stream(
             if os.path.realpath(path) != os.path.realpath(start_path):
                 cur_path = os.path.dirname(path)
                 while os.path.realpath(cur_path) != os.path.realpath(start_path):
-                    zf.writestr(f"{os.path.relpath(cur_path, start_path)}/", "")
+                    arcname = os.path.relpath(cur_path, start_path)
+                    if not _able_ascii_encode(arcname):
+                        raise ValueError(f"File name {arcname} cannot be encoded using ASCII. Please rename.")
+                    zf.write(cur_path, arcname)
                     cur_path = os.path.dirname(cur_path)
 
             if os.path.isdir(path):
-                for dirname, _, files in os.walk(path):
+                for dirpath, _, files in os.walk(path):
                     # ignore __pycache__
-                    if ignore_generated_py_file and "__pycache__" in dirname:
+                    if ignore_generated_py_file and "__pycache__" in dirpath:
                         continue
-                    zf.write(dirname, os.path.relpath(dirname, start_path))
+                    arcname = os.path.relpath(dirpath, start_path)
+                    if not _able_ascii_encode(arcname):
+                        raise ValueError(f"File name {arcname} cannot be encoded using ASCII. Please rename.")
+                    zf.write(dirpath, arcname)
                     for file in files:
                         # ignore generated python files
                         if ignore_generated_py_file and file.endswith(GENERATED_PY_FILE_EXT):
                             continue
-                        filename = os.path.join(dirname, file)
-                        zf.write(filename, os.path.relpath(filename, start_path))
+                        file_path = os.path.join(dirpath, file)
+                        arcname = os.path.relpath(file_path, start_path)
+                        if not _able_ascii_encode(arcname):
+                            raise ValueError(f"File name {arcname} cannot be encoded using ASCII. Please rename.")
+                        zf.write(file_path, arcname)
             else:
-                zf.write(path, os.path.relpath(path, start_path))
+                arcname = os.path.relpath(path, start_path)
+                if not _able_ascii_encode(arcname):
+                    raise ValueError(f"File name {arcname} cannot be encoded using ASCII. Please rename.")
+                zf.write(path, arcname)
 
         yield input_stream
 
@@ -116,19 +128,6 @@ def unzip_stream_in_temp_dir(stream: IO[bytes], temp_root: Optional[str] = None)
         yield tempdir
 
 
-@contextlib.contextmanager
-def zip_snowml() -> Generator[Tuple[io.BytesIO, str], None, None]:
-    """Zip the snowflake-ml source code as a zip-file for import.
-
-    Yields:
-        A bytes IO stream containing the zip file.
-    """
-    snowml_path = list(importlib.import_module("snowflake.ml").__path__)[0]
-    root_path = os.path.normpath(os.path.join(snowml_path, os.pardir, os.pardir))
-    with zip_file_or_directory_to_stream(snowml_path, root_path) as stream:
-        yield stream, hash_directory(snowml_path)
-
-
 def hash_directory(directory: Union[str, pathlib.Path]) -> str:
     """Hash the **content** of a folder recursively using SHA-1.
 
@@ -154,21 +153,17 @@ def hash_directory(directory: Union[str, pathlib.Path]) -> str:
     return _update_hash_from_dir(directory, hashlib.sha1()).hexdigest()
 
 
-def upload_snowml(session: snowpark_session.Session, stage_location: Optional[str] = None) -> str:
-    """Upload the SnowML local code into a stage if provided, or a session stage.
-    It will label the file name using the SHA-1 of the snowflake.ml folder, so that if the source code does not change,
-    it won't reupload. Any changes will, however, result a new zip file.
+def get_all_modules(dirname: str, prefix: str = "") -> List[pkgutil.ModuleInfo]:
+    subdirs = [f.path for f in os.scandir(dirname) if f.is_dir()]
+    modules = list(pkgutil.iter_modules(subdirs, prefix=prefix))
+    for dirname in subdirs:
+        modules.extend(get_all_modules(dirname, prefix=f"{prefix}.{dirname}" if prefix else dirname))
+    return modules
 
-    Args:
-        session: Snowpark connection session.
-        stage_location: The path to the stage location where the uploaded SnowML should be. Defaults to None.
 
-    Returns:
-        The path to the uploaded SnowML zip file.
-    """
-    with zip_snowml() as (stream, hash_str):
-        if stage_location is None:
-            stage_location = session.get_session_stage()
-        file_location = os.path.join(stage_location, f"snowml_{hash_str}.zip")
-        session.file.put_stream(stream, stage_location=file_location, auto_compress=False, overwrite=False)
-    return file_location
+def _able_ascii_encode(s: str) -> bool:
+    try:
+        s.encode("ascii", errors="strict")
+        return True
+    except UnicodeEncodeError:
+        return False

snowflake/ml/_internal/telemetry.py

@@ -6,7 +6,6 @@ import enum
 import functools
 import inspect
 import operator
-import threading
 import types
 from typing import (
     Any,
@@ -29,7 +28,6 @@ from snowflake.ml._internal import env
 from snowflake.snowpark import dataframe, exceptions, session
 from snowflake.snowpark._internal import utils
 
-_rlock = threading.RLock()
 _log_counter = 0
 _FLUSH_SIZE = 10
 
@@ -308,12 +306,11 @@ def send_api_usage_telemetry(
                 return res
             finally:
                 telemetry.send_function_usage_telemetry(**telemetry_args)
-                with _rlock:
-                    global _log_counter
-                    _log_counter += 1
-                    if _log_counter >= _FLUSH_SIZE or "error" in telemetry_args:
-                        telemetry.send_batch()
-                        _log_counter = 0
+                global _log_counter
+                _log_counter += 1
+                if _log_counter >= _FLUSH_SIZE or "error" in telemetry_args:
+                    telemetry.send_batch()
+                    _log_counter = 0
 
         return cast(Callable[_Args, _ReturnValue], wrap)
 

snowflake/ml/_internal/utils/identifier.py

@@ -4,14 +4,19 @@ from typing import Any, List, Optional, Tuple, Union, overload
 from snowflake.snowpark._internal.analyzer import analyzer_utils
 
 # Snowflake Identifier Regex. See https://docs.snowflake.com/en/sql-reference/identifiers-syntax.html.
-_SF_UNQUOTED_IDENTIFIER = "[A-Za-z_][A-Za-z0-9_$]*"
+_SF_UNQUOTED_CASE_INSENSITIVE_IDENTIFIER = "[A-Za-z_][A-Za-z0-9_$]*"
+_SF_UNQUOTED_CASE_SENSITIVE_IDENTIFIER = "[A-Z_][A-Z0-9_$]*"
 SF_QUOTED_IDENTIFIER = '"(?:[^"]|"")*"'
-_SF_IDENTIFIER = f"({_SF_UNQUOTED_IDENTIFIER}|{SF_QUOTED_IDENTIFIER})"
+_SF_IDENTIFIER = f"({_SF_UNQUOTED_CASE_INSENSITIVE_IDENTIFIER}|{SF_QUOTED_IDENTIFIER})"
 _SF_SCHEMA_LEVEL_OBJECT = rf"{_SF_IDENTIFIER}\.{_SF_IDENTIFIER}\.{_SF_IDENTIFIER}(.*)"
 _SF_SCHEMA_LEVEL_OBJECT_RE = re.compile(_SF_SCHEMA_LEVEL_OBJECT)
 
-UNQUOTED_CASE_INSENSITIVE_RE = re.compile(f"^({_SF_UNQUOTED_IDENTIFIER})$")
+UNQUOTED_CASE_INSENSITIVE_RE = re.compile(f"^({_SF_UNQUOTED_CASE_INSENSITIVE_IDENTIFIER})$")
+UNQUOTED_CASE_SENSITIVE_RE = re.compile(f"^({_SF_UNQUOTED_CASE_SENSITIVE_IDENTIFIER})$")
 QUOTED_IDENTIFIER_RE = re.compile(f"^({SF_QUOTED_IDENTIFIER})$")
+DOUBLE_QUOTE = '"'
+
+quote_name_without_upper_casing = analyzer_utils.quote_name_without_upper_casing
 
 
 def _is_quoted(id: str) -> bool:
@@ -61,10 +66,47 @@ def _get_unescaped_name(id: str) -> str:
     if not _is_quoted(id):
         return id.upper()
     unquoted_id = id[1:-1]
-    return unquoted_id.replace('""', '"')
+    return unquoted_id.replace(DOUBLE_QUOTE + DOUBLE_QUOTE, DOUBLE_QUOTE)
 
 
-quote_name_without_upper_casing = analyzer_utils.quote_name_without_upper_casing
+def _get_escaped_name(id: str) -> str:
+    """Add double quotes to escape quotes.
+        Replace double quotes with double double quotes if there is existing double quotes
+
+    NOTE: See note in :meth:`_is_quoted`.
+
+    Args:
+        id: The string to be checked & treated.
+
+    Returns:
+        String with quotes would doubled; original string would add double quotes.
+    """
+    escape_quotes = id.replace(DOUBLE_QUOTE, DOUBLE_QUOTE + DOUBLE_QUOTE)
+    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.
+
+    Examples:
+        COL1 -> COL1
+        1COL -> "1COL"
+        Col -> "Col"
+        "COL" -> \"""COL""\"  (ignore '\')
+        COL 1 -> "COL 1"
+
+    Args:
+        id: 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)
+    assert isinstance(escaped_id, str)
+    return escaped_id
 
 
 def concat_names(ids: List[str]) -> str:
@@ -89,7 +131,7 @@ def concat_names(ids: List[str]) -> str:
         parts.append(id)
     final_id = "".join(parts)
     if quotes_needed:
-        return quote_name_without_upper_casing(final_id)
+        return _get_escaped_name(final_id)
     return final_id
 
 
@@ -135,7 +177,7 @@ def get_unescaped_names(ids: List[str]) -> List[str]:
 
 def get_unescaped_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) in the
-    response pandas dataframe(i.e., in the respones of snowpark_df.to_pandas()) using the rules defined here
+    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.
 
     Args:
@@ -156,3 +198,28 @@ def get_unescaped_names(ids: Optional[Union[str, List[str]]]) -> Optional[Union[
         return _get_unescaped_name(ids)
     else:
         raise ValueError("Unsupported type. Only string or list of string are supported for selecting columns.")
+
+
+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)
+    in case of column name contains special characters, and maintains case-sensitivity
+    https://docs.snowflake.com/en/sql-reference/identifiers-syntax.
+
+    Args:
+        ids: User provided column name identifier(s).
+
+    Returns:
+        Double-quoted Identifiers for column names, to make sure that column names are case sensitive
+
+    Raises:
+        ValueError: if input types is unsupported or column name identifiers are invalid.
+    """
+
+    if ids 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)
+    else:
+        raise ValueError("Unsupported type. Only string or list of string are supported for selecting columns.")

snowflake/ml/_internal/utils/uri.py

@@ -1,4 +1,4 @@
-import os.path
+import posixpath
 from typing import Optional
 from urllib.parse import ParseResult, urlparse, urlunparse
 
@@ -35,7 +35,12 @@ def get_snowflake_stage_path_from_uri(uri: str) -> Optional[str]:
     if not is_snowflake_stage_uri(uri):
         return None
     uri_components = urlparse(uri)
-    return os.path.join(uri_components.netloc.strip("/"), uri_components.path.strip("/")).rstrip("/")
+    # posixpath.join will drop other components if any of arguments is absolute path.
+    # The path we get is actually absolute (starting with '/'), however, since we concat them to stage location,
+    # it should not.
+    return posixpath.normpath(
+        posixpath.join(posixpath.normpath(uri_components.netloc), posixpath.normpath(uri_components.path.lstrip("/")))
+    )
 
 
 def get_uri_scheme(uri: str) -> str:

snowflake/ml/model/_core_requirements.py

@@ -1 +1 @@
-REQUIREMENTS=['anyio>=3.5.0,<4', 'cloudpickle', 'numpy>=1.23,<2', 'packaging>=20.9,<24', 'pandas>=1.0.0,<2', 'pyyaml>=6.0,<7', 'scikit-learn>=1.2.1,<2', 'snowflake-snowpark-python>=1.4.0,<2', 'typing-extensions>=4.1.0,<5']
+REQUIREMENTS=['anyio>=3.5.0,<4', 'cloudpickle', 'numpy>=1.23,<2', 'packaging>=20.9,<24', 'pandas>=1.0.0,<2', 'pyyaml>=6.0,<7', 'snowflake-snowpark-python>=1.4.0,<2', 'typing-extensions>=4.1.0,<5']

snowflake/ml/model/_deploy_client/image_builds/base_image_builder.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+
+
+class ImageBuilder(ABC):
+    """
+    Abstract class encapsulating image building and upload to model registry.
+    """
+
+    @abstractmethod
+    def build_and_upload_image(self) -> str:
+        """Builds and uploads an image to the model registry.
+
+        Returns: Full image path.
+        """
+        pass

snowflake/ml/model/_deploy_client/image_builds/client_image_builder.py

@@ -0,0 +1,259 @@
+import base64
+import json
+import logging
+import os
+import posixpath
+import subprocess
+import tempfile
+import zipfile
+from enum import Enum
+from typing import List
+
+import yaml
+
+from snowflake import snowpark
+from snowflake.ml._internal.utils import query_result_checker
+from snowflake.ml.model._deploy_client.image_builds import (
+    base_image_builder,
+    docker_context,
+)
+from snowflake.ml.model._deploy_client.utils import constants
+
+
+class Platform(Enum):
+    LINUX_AMD64 = "linux/amd64"
+
+
+class ClientImageBuilder(base_image_builder.ImageBuilder):
+    """
+    Client-side image building and upload to model registry.
+
+    Usage requirements:
+    Requires prior installation and running of Docker with BuildKit. See installation instructions in
+        https://docs.docker.com/engine/install/
+
+
+    """
+
+    def __init__(
+        self, *, id: str, image_repo: str, model_zip_stage_path: str, session: snowpark.Session, use_gpu: bool = False
+    ) -> None:
+        """Initialization
+
+        Args:
+            id: A hexadecimal string used for naming the image tag.
+            image_repo: Path to image repository.
+            model_zip_stage_path: Path to model zip file in stage.
+            use_gpu: Boolean flag for generating the CPU or GPU base image.
+            session: Snowpark session
+        """
+        self.image_tag = "/".join([image_repo.rstrip("/"), id]) + ":latest"
+        self.image_repo = image_repo
+        self.model_zip_stage_path = model_zip_stage_path
+        self.use_gpu = use_gpu
+        self.session = session
+
+    def build_and_upload_image(self) -> str:
+        """
+        Builds and uploads an image to the model registry.
+        """
+
+        def _setup_docker_config(docker_config_dir: str) -> None:
+            """Set up a temporary docker config, which is used for running all docker commands.
+
+            Args:
+                docker_config_dir: Path to docker configuration directory, which stores the temporary session token.
+            """
+            ctx = self.session._conn._conn
+            assert ctx._rest, "SnowflakeRestful is not set in session"
+            token_data = ctx._rest._token_request("ISSUE")
+            snowpark_session_token = token_data["data"]["sessionToken"]
+            token_obj = {"token": snowpark_session_token}
+            credentials = f"0sessiontoken:{json.dumps(token_obj)}"
+            encoded_credentials = base64.b64encode(credentials.encode("utf-8")).decode("utf-8")
+            content = {"auths": {self.image_tag: {"auth": encoded_credentials}}}
+            config_path = os.path.join(docker_config_dir, "config.json")
+            with open(config_path, "w", encoding="utf-8") as file:
+                json.dump(content, file)
+
+        self.validate_docker_client_env()
+
+        query_result = (
+            query_result_checker.SqlResultValidator(
+                self.session,
+                query="SHOW PARAMETERS LIKE 'PYTHON_CONNECTOR_QUERY_RESULT_FORMAT' IN SESSION",
+            )
+            .has_dimensions(expected_rows=1)
+            .validate()
+        )
+        prev_format = query_result[0].value
+
+        with tempfile.TemporaryDirectory() as config_dir:
+            try:
+                # Workaround for SNOW-841699: Fail to authenticate to image registry with session token generated from
+                # Snowpark. Need to temporarily set the json query format in order to process GS token response.
+                self.session.sql("ALTER SESSION SET PYTHON_CONNECTOR_QUERY_RESULT_FORMAT = 'json'").collect()
+                _setup_docker_config(config_dir)
+                self._build(config_dir)
+                self._upload(config_dir)
+            finally:
+                self.session.sql(f"ALTER SESSION SET PYTHON_CONNECTOR_QUERY_RESULT_FORMAT = '{prev_format}'").collect()
+                commands = ["docker", "--config", config_dir, "rmi", self.image_tag]
+                logging.info(f"Removing local image: {self.image_tag}")
+                self._run_docker_commands(commands)
+        return self.image_tag
+
+    def validate_docker_client_env(self) -> None:
+        """Ensure docker client is running and BuildKit is enabled. Note that Buildx always uses BuildKit.
+        - Ensure docker daemon is running through the "docker info" command on shell. When docker daemon is running,
+        return code will be 0, else return code will be 1.
+        - Ensure BuildKit is enabled by checking "docker buildx version".
+
+        Raises:
+            ConnectionError: Occurs when Docker is not installed or is not running.
+
+        """
+        info_command = "docker info"
+        buildx_command = "docker buildx version"
+
+        try:
+            subprocess.check_call(info_command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, shell=True)
+        except subprocess.CalledProcessError:
+            raise ConnectionError("Failed to initialize Docker client. Please ensure Docker is installed and running.")
+
+        try:
+            subprocess.check_call(buildx_command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, shell=True)
+        except subprocess.CalledProcessError:
+            raise ConnectionError(
+                "Please ensured Docker is installed with BuildKit by following "
+                "https://docs.docker.com/build/buildkit/#getting-started"
+            )
+
+    def _extract_model_zip(self, context_dir: str) -> str:
+        """Extract a zip file into the specified directory.
+
+        Args:
+            context_dir: Directory to extract the zip to.
+
+        Returns:
+            The extracted model directory.
+        """
+
+        local_model_zip_path = os.path.join(context_dir, posixpath.basename(self.model_zip_stage_path))
+        if zipfile.is_zipfile(local_model_zip_path):
+            extracted_model_dir = os.path.join(context_dir, constants.MODEL_DIR)
+            with zipfile.ZipFile(local_model_zip_path, "r") as model_zip:
+                if len(model_zip.namelist()) > 1:
+                    model_zip.extractall(extracted_model_dir)
+            conda_path = os.path.join(extracted_model_dir, "env", "conda.yaml")
+
+            def remove_snowml_from_conda() -> None:
+                with open(conda_path, encoding="utf-8") as file:
+                    conda_yaml = yaml.safe_load(file)
+
+                dependencies = conda_yaml["dependencies"]
+                dependencies = [dep for dep in dependencies if not dep.startswith("snowflake-ml-python")]
+
+                conda_yaml["dependencies"] = dependencies
+
+                with open(conda_path, "w", encoding="utf-8") as file:
+                    yaml.dump(conda_yaml, file)
+
+            # TODO(shchen): Remove once SNOW-840411 is landed.
+            remove_snowml_from_conda()
+        return extracted_model_dir
+
+    def _build(self, docker_config_dir: str) -> None:
+        """Constructs the Docker context directory and then builds a Docker image based on that context.
+
+        Args:
+            docker_config_dir: Path to docker configuration directory, which stores the temporary session token.
+        """
+
+        with tempfile.TemporaryDirectory() as context_dir:
+            # Download the model zip file that is already uploaded to stage during model registry log_model step.
+            # This is needed in order to obtain the conda and requirement file inside the model zip.
+            self.session.file.get(self.model_zip_stage_path, context_dir)
+
+            extracted_model_dir = self._extract_model_zip(context_dir)
+
+            dc = docker_context.DockerContext(
+                context_dir=context_dir, model_dir=extracted_model_dir, use_gpu=self.use_gpu
+            )
+            dc.build()
+            self._build_image_from_context(context_dir=context_dir, docker_config_dir=docker_config_dir)
+
+    def _run_docker_commands(self, commands: List[str]) -> None:
+        """Run docker commands in a new child process.
+
+        Args:
+            commands: List of commands to run.
+
+        Raises:
+            RuntimeError: Occurs when docker commands failed to execute.
+        """
+        proc = subprocess.Popen(commands, cwd=os.getcwd(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        output_lines = []
+
+        if proc.stdout:
+            for line in iter(proc.stdout.readline, ""):
+                output_lines.append(line)
+                logging.info(line)
+
+        if proc.wait():
+            raise RuntimeError(f"Docker build failed: {''.join(output_lines)}")
+
+    def _build_image_from_context(
+        self, context_dir: str, docker_config_dir: str, *, platform: Platform = Platform.LINUX_AMD64
+    ) -> None:
+        """Builds a Docker image based on provided context.
+
+        Args:
+            context_dir: Path to context directory.
+            docker_config_dir: Path to docker configuration directory, which stores the temporary session token.
+            platform: Target platform for the build output, in the format "os[/arch[/variant]]".
+        """
+
+        commands = [
+            "docker",
+            "--config",
+            docker_config_dir,
+            "buildx",
+            "build",
+            "--platform",
+            platform.value,
+            "--tag",
+            f"{self.image_tag}",
+            context_dir,
+        ]
+
+        self._run_docker_commands(commands)
+
+    def _upload(self, docker_config_dir: str) -> None:
+        """
+        Uploads image to the image registry. This process requires a "docker login" followed by a "docker push". Remove
+        local image at the end of the upload operation to save up local space. Image cache is kept for more performant
+        built experience at the cost of small storage footprint.
+
+        For image registry authentication, we will use a session token obtained from the Snowpark session object.
+        The token authentication mechanism is automatically used when the username is set to "0sessiontoken" according
+        to the registry implementation detailed in the following link:
+        https://github.com/snowflakedb/snowflake-image-registry/blob/277435c6fd79db2df9f863aa9d04dc875e034d85
+        /AuthAdapter/src/main/java/com/snowflake/registry/service/AuthHeader.java#L122
+
+        By default, Docker overwrites the local Docker config file "/.docker/config.json" whenever a docker login
+        occurs. However, to ensure better isolation between Snowflake-managed Docker credentials and the user's own
+        Docker credentials, we will not use the default Docker config. Instead, we will write the username and session
+        token to a temporary file and use "docker --config" so that it only applies to the specific Docker command being
+        executed, without affecting the user's local Docker setup. The credential file will be automatically removed
+        at the end of upload operation.
+
+        Args:
+            docker_config_dir: Path to docker configuration directory, which stores the temporary session token.
+        """
+        commands = ["docker", "--config", docker_config_dir, "login", self.image_tag]
+        self._run_docker_commands(commands)
+
+        logging.info(f"Pushing image to image repo {self.image_tag}")
+        commands = ["docker", "--config", docker_config_dir, "push", self.image_tag]
+        self._run_docker_commands(commands)