oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.9rc1__py3-none-any.whl

ads/opctl/conda/cmds.py

@@ -0,0 +1,749 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2022 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import datetime
+import os
+import shutil
+import subprocess
+import shlex
+import json
+import glob
+from typing import Dict
+
+import click
+import yaml
+
+from datetime import datetime
+import ocifs
+
+from ads.common.oci_client import OCIClientFactory
+from ads.common.auth import create_signer
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+from ads.config import NO_CONTAINER
+
+from ads.opctl.constants import (
+    ML_JOB_GPU_IMAGE,
+    ML_JOB_IMAGE,
+    DEFAULT_IMAGE_HOME_DIR,
+    DEFAULT_IMAGE_CONDA_DIR,
+    DEFAULT_NOTEBOOK_SESSION_SPARK_CONF_DIR,
+)
+from ads.opctl import logger
+from ads.opctl.config.utils import read_from_ini
+from ads.opctl.utils import (
+    parse_conda_uri,
+    run_container,
+    get_docker_client,
+    is_in_notebook_session,
+    run_command,
+)
+from ads.opctl.config.base import ConfigProcessor
+from ads.opctl.config.merger import ConfigMerger
+from ads.opctl.conda.multipart_uploader import MultiPartUploader
+import tempfile
+
+
+def _fetch_manifest_template() -> Dict:
+    manifest_template_file = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), "manifest_template.yaml"
+    )
+    with open(manifest_template_file) as manifest_file:
+        manifest_template = yaml.safe_load(manifest_file)
+    return manifest_template
+
+
+@runtime_dependency(module="docker", install_from=OptionalDependency.OPCTL)
+def _check_job_image_exists(gpu: bool) -> None:
+    if gpu:
+        image = ML_JOB_GPU_IMAGE
+    else:
+        image = ML_JOB_IMAGE
+    try:
+        client = get_docker_client()
+        client.api.inspect_image(image)
+    except docker.errors.ImageNotFound:
+        if gpu:
+            cmd = "`ads opctl build-image -g job-local`"
+        else:
+            cmd = "`ads opctl build-image job-local`"
+        raise RuntimeError(
+            f"Please run {cmd} to build a local image for Jobs development first."
+        )
+
+
+def _get_name(name: str, env_file: str) -> str:
+    if not name and env_file:
+        with open(env_file) as f:
+            name = yaml.safe_load(f.read()).get("manifest").get("name", None)
+    if not name:
+        raise ValueError(
+            "Either specify environment name in environment yaml or with `--name`."
+        )
+    return name
+
+
+def create(**kwargs) -> str:
+    p = ConfigProcessor().step(ConfigMerger, **kwargs)
+    exec_config = p.config["execution"]
+    name = _get_name(exec_config.get("name"), exec_config.get("environment_file"))
+    _create(
+        name=name,
+        version=exec_config["version"],
+        env_file=exec_config["environment_file"],
+        conda_pack_folder=exec_config["conda_pack_folder"],
+        gpu=exec_config.get("gpu", False),
+        overwrite=exec_config.get("overwrite", False),
+    )
+
+
+def _create(
+    name: str,
+    version: str,
+    env_file: str,
+    conda_pack_folder: str,
+    gpu: bool,
+    overwrite: bool,
+    prepare_publish: bool = False,
+) -> str:
+    """Create a conda pack given an environment yaml file under conda pack folder specified.
+
+    Parameters
+    ----------
+    slug : str
+        slug of the conda pack
+    env_file : str
+        path to conda environment yaml
+    conda_pack_folder : str
+        path to conda pack folder
+    gpu : bool
+        whether to build against GPU image
+    overwrite : bool
+        whether to overwrite existing pack of the same slug
+    prepare_pubish : bool
+        whether to create conda pack archive after conda pack is created
+
+    Raises
+    ------
+    FileNotFoundError
+        Environment file not found
+    RuntimeError
+        Environment file may be inproperly removed
+    RuntimeError
+        Creating pack failed
+
+    Return
+    ------
+    str:
+        slug of the environment
+    """
+
+    if not os.path.exists(env_file):
+        raise FileNotFoundError(f"Environment file {env_file} is not found.")
+
+    conda_dep = None
+    with open(env_file) as mfile:
+        conda_dep = yaml.safe_load(mfile.read())
+    # If manifest exists in the environment.yaml file, use that
+    manifest = conda_dep.get("manifest", {})
+    slug = manifest.get(
+        "slug", f"{name}_v{version}".replace(" ", "").replace(".", "_").lower()
+    )
+    pack_folder_path = os.path.join(
+        os.path.abspath(os.path.expanduser(conda_pack_folder)), slug
+    )
+
+    if os.path.exists(pack_folder_path):
+        overwrite = overwrite or click.confirm(
+            f"Conda pack with slug {slug} already exists. Do you wish to overwrite?"
+        )
+        if overwrite:
+            if (
+                os.path.commonpath(
+                    [pack_folder_path, os.path.abspath(os.path.expanduser(env_file))]
+                )
+                == pack_folder_path
+            ):
+                raise RuntimeError(
+                    f"Environment file {os.path.abspath(os.path.expanduser(env_file))} is in {pack_folder_path}. Overwriting this folder will remove the file."
+                )
+            shutil.rmtree(pack_folder_path)
+        else:
+            return
+
+    os.makedirs(pack_folder_path, exist_ok=True)
+
+    logger.info(
+        f"Preparing manifest. Manifest in the environment: {conda_dep.get('manifest')}"
+    )
+    manifest_template = _fetch_manifest_template()
+    if "name" not in manifest:
+        manifest_template["manifest"]["name"] = name
+    manifest_template["manifest"]["slug"] = slug
+    if "type" not in manifest:
+        logger.info("Setting manifest to published")
+        manifest_template["manifest"]["type"] = "published"
+    if "version" not in manifest:
+        manifest_template["manifest"]["version"] = version
+    manifest_template["manifest"]["arch_type"] = "GPU" if gpu else "CPU"
+
+    manifest_template["manifest"]["create_date"] = datetime.utcnow().strftime(
+        "%a, %b %d, %Y, %H:%M:%S %Z UTC"
+    )
+
+    if not "manifest_version" in manifest:
+        manifest_template["manifest"]["manifest_version"] = "1.0"
+
+    logger.info(f"Creating conda environment {slug}")
+    manifest_dict = {
+        k: manifest_template["manifest"][k]
+        for k in manifest_template["manifest"]
+        if manifest_template["manifest"][k]
+    }
+    if "manifest" in conda_dep:
+        conda_dep["manifest"].update(manifest_dict)
+    else:
+        conda_dep["manifest"] = manifest_dict
+    logger.info(f"Updated conda environment manifest: {conda_dep.get('manifest')}")
+
+    if is_in_notebook_session() or NO_CONTAINER:
+        command = f"conda env create --prefix {pack_folder_path} --file {os.path.abspath(os.path.expanduser(env_file))}"
+        proc = run_command(command, shell=True)
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"Failed to create conda environment. (exit code {proc.returncode})"
+            )
+    else:
+        _check_job_image_exists(gpu)
+        docker_pack_folder_path = os.path.join(DEFAULT_IMAGE_HOME_DIR, slug)
+        docker_env_file_path = os.path.join(
+            DEFAULT_IMAGE_HOME_DIR, os.path.basename(env_file)
+        )
+
+        create_command = f"conda env create --prefix {docker_pack_folder_path} --file {docker_env_file_path}"
+
+        volumes = {
+            pack_folder_path: {"bind": docker_pack_folder_path},
+            os.path.abspath(os.path.expanduser(env_file)): {
+                "bind": docker_env_file_path
+            },
+        }
+
+        if gpu:
+            image = ML_JOB_GPU_IMAGE
+        else:
+            image = ML_JOB_IMAGE
+        try:
+            if prepare_publish:
+                tmp_file = tempfile.NamedTemporaryFile(suffix=".yaml")
+                # Save the manifest in the temp file that can be mounted inside the container so that archiving will work
+                with open(tmp_file.name, "w") as f:
+                    yaml.safe_dump(conda_dep, f)
+
+                pack_script = os.path.join(
+                    os.path.dirname(os.path.abspath(__file__)), "pack.py"
+                )
+                pack_command = f"python {os.path.join(DEFAULT_IMAGE_HOME_DIR, 'pack.py')} --conda-path {docker_pack_folder_path} --manifest-location {os.path.join(DEFAULT_IMAGE_HOME_DIR, 'manifest.yaml')}"
+
+                # add pack script and manifest file to the mount so that archive can be created in the same container run
+                condapack_script = {
+                    pack_script: {
+                        "bind": os.path.join(DEFAULT_IMAGE_HOME_DIR, "pack.py")
+                    },
+                    tmp_file.name: {
+                        "bind": os.path.join(DEFAULT_IMAGE_HOME_DIR, "manifest.yaml")
+                    },
+                }
+                volumes = {
+                    **volumes,
+                    **condapack_script,
+                }  # | not supported in python 3.8
+
+                run_container(
+                    image=image,
+                    bind_volumes=volumes,
+                    entrypoint="/bin/bash -c ",
+                    env_vars={},
+                    command=f" '{create_command} && {pack_command}'",
+                )
+            else:
+                run_container(
+                    image=image,
+                    bind_volumes=volumes,
+                    env_vars={},
+                    command=create_command,
+                )
+        except Exception:
+            if os.path.exists(pack_folder_path):
+                shutil.rmtree(pack_folder_path)
+            raise RuntimeError(f"Could not create environment {slug}.")
+
+    # Save the manifest file inside the host machine, where the conda environment is saved.
+    manifest_location = f"{os.path.join(pack_folder_path, slug)}_manifest.yaml"
+    with open(manifest_location, "w") as mfile:
+        yaml.safe_dump(conda_dep, mfile)
+
+    logger.info(f"Environment `{slug}` setup complete.")
+    print(f"Pack {slug} created under {pack_folder_path}.")
+
+    return slug
+
+
+def _fetch_pack_path(
+    slug: str,
+    conda_pack_os_prefix: str,
+    oci_config: str,
+    oci_profile: str,
+    auth_type: str,
+) -> str:
+    oci_auth = create_signer(auth_type, oci_config, oci_profile)
+    fs = ocifs.OCIFileSystem(**oci_auth)
+    fnames = fs.ls(conda_pack_os_prefix, detail=True, refresh=True)
+    for f in fnames:
+        if os.path.basename(f["name"]) == slug:
+            return f"oci://{f['name']}"
+        elif f["type"] == "directory":
+            path = _fetch_pack_path(
+                slug, f"oci://{f['name']}", oci_config, oci_profile, auth_type
+            )
+            if path:
+                return path
+    return None
+
+
+def install(**kwargs) -> None:
+    p = ConfigProcessor().step(ConfigMerger, **kwargs)
+    exec_config = p.config["execution"]
+    if exec_config.get("slug") and exec_config.get("conda_pack_os_prefix"):
+        conda_uri = _fetch_pack_path(
+            exec_config["slug"],
+            exec_config["conda_pack_os_prefix"],
+            exec_config.get("oci_config"),
+            exec_config.get("oci_profile"),
+            exec_config.get("auth"),
+        )
+        if not conda_uri:
+            raise FileNotFoundError(
+                f"{exec_config['slug']} not found under {exec_config['conda_pack_os_prefix']}"
+            )
+    elif exec_config.get("conda_uri"):
+        conda_uri = exec_config["conda_uri"]
+    else:
+        raise ValueError(
+            "Either `--conda-uri`, or `--slug` and `--conda-pack-os-prefix` has to be specified."
+        )
+    _install(
+        conda_uri,
+        os.path.abspath(os.path.expanduser(exec_config["conda_pack_folder"])),
+        exec_config.get("oci_config"),
+        exec_config.get("oci_profile"),
+        overwrite=exec_config.get("overwrite", False),
+        debug=kwargs.get("debug", False),
+        auth_type=exec_config.get("auth"),
+    )
+
+
+def _install(
+    conda_uri: str,
+    conda_pack_folder: str,
+    oci_config: str = None,
+    oci_profile: str = None,
+    overwrite: bool = False,
+    debug: bool = False,
+    auth_type: str = None,
+) -> None:
+    """
+    Install conda pack.
+
+    Parameters
+    ----------
+    conda_uri: str
+        OCI object storage uri to conda pack
+    conda_pack_folder: str
+        local folder to save conda packs
+    oci_config: str
+        path to OCI config file
+    oci_profile: str
+        OCI config profile
+    overwrite: bool
+        whether to overwrite existing pack
+    debug: bool
+        whether to turn on debug mode
+    auth_type : str
+        authentication method
+    Returns
+    -------
+    None
+    """
+    ns, bucket, path, slug = parse_conda_uri(conda_uri)
+    if bucket == "service-conda-packs":
+        raise ValueError(
+            "Download service conda pack is not allowed. Only custom conda pack can be downloaded to local machine. You need to publish it to your own bucket first."
+        )
+    os.makedirs(conda_pack_folder, exist_ok=True)
+    pack_path = os.path.join(os.path.expanduser(conda_pack_folder), slug + ".tar.gz")
+    pack_folder_path = os.path.join(os.path.expanduser(conda_pack_folder), slug)
+
+    if not (is_in_notebook_session() or NO_CONTAINER):
+        _check_job_image_exists(gpu=False)
+
+    while os.path.exists(pack_folder_path):
+        if overwrite:
+            break
+        else:
+            ans = click.prompt(
+                f"conda pack with slug {slug} already exists. Enter a new name or 'o' for overwrite:",
+                default="o",
+            )
+            if ans == "o":
+                overwrite = True
+                break
+            else:
+                slug = ans
+                pack_path = os.path.join(
+                    os.path.expanduser(conda_pack_folder), slug + ".tar.gz"
+                )
+                pack_folder_path = os.path.join(
+                    os.path.expanduser(conda_pack_folder), slug
+                )
+
+    if oci_config is None or oci_profile is None:
+        download_command = [
+            "oci",
+            "os",
+            "object",
+            "get",
+            "--name",
+            f"{path}",
+            "-bn",
+            bucket,
+            "-ns",
+            ns,
+            "--file",
+            pack_path,
+            "--auth",
+            auth_type,
+        ]
+    else:
+        oci_config = os.path.abspath(os.path.expanduser(oci_config))
+        parser = read_from_ini(os.path.expanduser(oci_config))
+        if oci_profile not in parser:
+            raise ValueError(f"PROFILE {oci_profile} not found in {oci_config}.")
+        download_command = [
+            "oci",
+            "os",
+            "object",
+            "get",
+            "--name",
+            f"{path}",
+            "-bn",
+            bucket,
+            "-ns",
+            ns,
+            "--file",
+            pack_path,
+            "--profile",
+            oci_profile,
+            "--config-file",
+            oci_config,
+        ]
+    if debug:
+        download_command.append("-d")
+        print(" ".join([shlex.quote(c) for c in download_command]))
+    process = subprocess.Popen(download_command)
+    process.communicate()
+    if process.returncode != 0:
+        if os.path.exists(pack_path):
+            os.remove(pack_path)
+        raise RuntimeError(
+            f"Downloading pack failed with return code {process.returncode}. Please double check the path and make sure you have access."
+        )
+    else:
+        print(f"Download {conda_uri} completed")
+
+    print(f"Start unpacking {pack_path}")
+    os.makedirs(pack_folder_path, exist_ok=True)
+
+    process = subprocess.Popen(["tar", "-xf", pack_path, "-C", pack_folder_path])
+    process.communicate()
+    if process.returncode != 0:
+        shutil.rmtree(pack_folder_path)
+        raise Exception(
+            f"Error extracting {pack_path} to {pack_folder_path}. Please try again."
+        )
+
+    # Run the conda-unpack script to clean up prefixes
+    # This will fix problems related to repeated "placehold" paths.
+    # See https://conda.github.io/conda-pack/#commandline-usage
+    unpack_script = os.path.join(pack_folder_path, "bin", "conda-unpack")
+    if os.path.exists(unpack_script):
+        if is_in_notebook_session() or NO_CONTAINER:
+            run_command(unpack_script)
+        else:
+            volumes = {
+                pack_folder_path: {"bind": os.path.join(DEFAULT_IMAGE_HOME_DIR, slug)}
+            }
+            try:
+                run_container(
+                    image=ML_JOB_IMAGE,
+                    bind_volumes=volumes,
+                    env_vars={},
+                    command=os.path.join(
+                        DEFAULT_IMAGE_HOME_DIR, slug, "bin/conda-unpack"
+                    ),
+                )
+            except Exception:
+                raise RuntimeError(f"Error unpacking environment {slug}.")
+        if os.path.exists(os.path.join(pack_folder_path, "spark-defaults.conf")):
+            if is_in_notebook_session() or NO_CONTAINER:
+                if not os.path.exists(DEFAULT_NOTEBOOK_SESSION_SPARK_CONF_DIR):
+                    os.makedirs(DEFAULT_NOTEBOOK_SESSION_SPARK_CONF_DIR)
+                    shutil.copy(
+                        os.path.join(pack_folder_path, "spark-defaults.conf"),
+                        DEFAULT_NOTEBOOK_SESSION_SPARK_CONF_DIR,
+                    )
+                    for file in os.listdir(pack_folder_path):
+                        if os.path.splitext(file)[1] == ".jar":
+                            shutil.copy(
+                                os.path.join(pack_folder_path, file),
+                                DEFAULT_NOTEBOOK_SESSION_SPARK_CONF_DIR,
+                            )
+            else:
+                with open(os.path.join(pack_folder_path, "spark-defaults.conf")) as f:
+                    confs = f.read()
+                confs = confs.replace(
+                    DEFAULT_NOTEBOOK_SESSION_SPARK_CONF_DIR,
+                    os.path.join(DEFAULT_IMAGE_CONDA_DIR, slug),
+                )
+                with open(
+                    os.path.join(pack_folder_path, "spark-defaults.conf"), "w"
+                ) as f:
+                    f.write(confs)
+
+    os.remove(pack_path)
+    manifest_path = glob.glob(os.path.join(pack_folder_path, "*_manifest.yaml"))[0]
+    with open(manifest_path) as f:
+        env = yaml.safe_load(f.read())
+    env["manifest"]["pack_uri"] = conda_uri
+    with open(manifest_path, "w") as f:
+        yaml.safe_dump(env, f)
+    print(f"{slug} set up at {pack_folder_path}.")
+
+
+def publish(**kwargs) -> None:
+    p = ConfigProcessor().step(ConfigMerger, **kwargs)
+    exec_config = p.config["execution"]
+    skip_archive = False
+    if exec_config.get("environment_file", None):
+        name = _get_name(exec_config.get("name"), exec_config.get("environment_file"))
+        slug = _create(
+            name=name,
+            version=exec_config["version"],
+            env_file=exec_config["environment_file"],
+            conda_pack_folder=exec_config["conda_pack_folder"],
+            gpu=exec_config.get("gpu", False),
+            overwrite=exec_config["overwrite"],
+            prepare_publish=True,
+        )
+        skip_archive = (
+            True  # The conda pack archive is already created during create process.
+        )
+    else:
+        slug = exec_config.get("slug")
+    if not slug:
+        raise ValueError("Please specify slug of the conda pack via `--slug`.")
+    if not exec_config.get("conda_pack_os_prefix"):
+        raise ValueError(
+            "Please specify object storage path to save conda pack either via `ads opctl configure` or `--conda-pack-os-prefix`."
+        )
+    _publish(
+        conda_slug=slug,
+        conda_uri_prefix=exec_config["conda_pack_os_prefix"],
+        conda_pack_folder=exec_config["conda_pack_folder"],
+        oci_config=exec_config.get("oci_config"),
+        oci_profile=exec_config.get("oci_profile"),
+        overwrite=exec_config["overwrite"],
+        auth_type=exec_config["auth"],
+        skip_archive=skip_archive,
+    )
+
+
+def _publish(
+    conda_slug: str,
+    conda_uri_prefix: str,
+    conda_pack_folder: str,
+    oci_config: str,
+    oci_profile: str,
+    overwrite: bool,
+    auth_type: str,
+    skip_archive: bool = False,
+) -> None:
+    """Publish a local conda pack to object storage location
+
+    Parameters
+    ----------
+    conda_slug : str
+        slug of conda pack
+    conda_uri_prefix : str
+        object storage prefix to save conda pack
+    conda_pack_folder : str
+        path to local conda folder
+    oci_config : str
+        oci config file path
+    oci_profile : str
+        oci config profile
+    overwrite : bool
+        whether to overwrite existing pack of the same slug
+    auth_type : str
+        authentication method
+
+    Raises
+    ------
+    FileNotFoundError
+        local conda pack folder not found
+    FileNotFoundError
+        manifest file not found inside conda pack
+    RuntimeError
+        IP packages found inside conda pack
+    RuntimeError
+        Packing conda failed
+    RuntimeError
+        Pack file not found
+    """
+    ns, bucket, prefix, _ = parse_conda_uri(conda_uri_prefix)
+
+    # ======= check if conda pack and manifest exists ==============
+    pack_folder_path = os.path.abspath(
+        os.path.expanduser(os.path.join(conda_pack_folder, conda_slug))
+    )
+    if not os.path.exists(pack_folder_path):
+        raise FileNotFoundError(
+            f"Could not find environment {conda_slug} in {conda_pack_folder}."
+        )
+    paths = glob.glob(os.path.join(pack_folder_path, "*_manifest.yaml"))
+    if len(paths) != 1:
+        raise FileNotFoundError(
+            "Could not locate manifest file in the provided environment."
+        )
+    else:
+        manifest_location = paths[0]
+
+    # ===== check if pack contains IP packages =========
+    print(f"Loading environment information from {manifest_location}.")
+    with open(manifest_location) as mlf:
+        env = yaml.safe_load(mlf.read())
+    if "IP" in env["manifest"] and env["manifest"]["IP"].lower() == "y":
+        raise RuntimeError("This environment has IP restricted packages.")
+
+    oci_auth = create_signer(auth_type, oci_config, oci_profile)
+    client = OCIClientFactory(**oci_auth).object_storage
+    publish_slug = conda_slug
+    if not overwrite:
+        existing_packs = client.list_objects(ns, bucket, prefix=prefix).data.objects
+        pack_names = [os.path.basename(pack.name) for pack in existing_packs]
+        while publish_slug in pack_names:
+            ans = click.prompt(
+                f"{conda_slug} exists in {conda_uri_prefix}. Enter a new name or overwrite (o)",
+                default="o",
+            )
+            if ans == "o":
+                break
+            else:
+                publish_slug = "_".join(ans.lower().split(" "))
+
+    pack_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pack.py")
+    if not skip_archive:
+        if is_in_notebook_session() or NO_CONTAINER:
+            # Set the CONDA_PUBLISH_TYPE environment variable so that the `type` attribute inside the manifest is not changed
+            publish_type = os.environ.get("CONDA_PUBLISH_TYPE")
+            command = f"python {pack_script} --conda-path {pack_folder_path}"
+            if publish_type:
+                command = f"CONDA_PUBLISH_TYPE={publish_type} {command}"
+            proc = run_command(command, shell=True)
+            if proc.returncode != 0:
+                raise RuntimeError(
+                    f"Failed to archive the conda environment. (exit code {proc.returncode})"
+                )
+        else:
+            volumes = {
+                pack_folder_path: {
+                    "bind": os.path.join(DEFAULT_IMAGE_HOME_DIR, conda_slug)
+                },
+                pack_script: {"bind": os.path.join(DEFAULT_IMAGE_HOME_DIR, "pack.py")},
+            }
+            command = f"python {os.path.join(DEFAULT_IMAGE_HOME_DIR, 'pack.py')} --conda-path {os.path.join(DEFAULT_IMAGE_HOME_DIR, conda_slug)}"
+            gpu = env["manifest"]["arch_type"] == "GPU"
+            _check_job_image_exists(gpu)
+            if gpu:
+                image = ML_JOB_GPU_IMAGE
+            else:
+                image = ML_JOB_IMAGE
+            try:
+                run_container(
+                    image=image, bind_volumes=volumes, env_vars={}, command=command
+                )
+            except Exception:
+                raise RuntimeError(f"Could not pack environment {conda_slug}.")
+    NOT_ALLOWED_CHARS = "@#$%^&*/"
+
+    if any(chr in conda_slug for chr in NOT_ALLOWED_CHARS):
+        raise ValueError(
+            f"Invalid conda_slug. Found {NOT_ALLOWED_CHARS} in slug name. Please use a different slug name."
+        )
+    pack_file = os.path.join(pack_folder_path, f"{conda_slug}.tar.gz")
+    if not os.path.exists(pack_file):
+        raise RuntimeError(f"Pack {pack_file} was not created.")
+    pack_size = round(os.path.getsize(pack_file) / 2**20, 2)
+
+    with open(manifest_location) as mlf:
+        env = yaml.safe_load(mlf.read())
+    manifest = env["manifest"]
+    manifest["slug"] = conda_slug
+    manifest["create_date"] = datetime.utcnow().strftime(
+        "%a, %b %d, %Y, %H:%M:%S %Z UTC"
+    )
+    manifest["size_mb"] = pack_size
+    ns, bucket, prefix, _ = parse_conda_uri(conda_uri_prefix)
+
+    pack_uri = os.path.join(
+        conda_uri_prefix,
+        manifest.get("arch_type", "CPU").lower(),
+        manifest["name"],
+        str(manifest["version"]),
+        publish_slug,
+    )
+    if os.environ.get("CONDA_PUBLISH_TYPE") != "service":
+        # Set these values only for published conda pack
+        manifest["pack_path"] = os.path.join(
+            prefix,
+            manifest.get("arch_type", "CPU").lower(),
+            manifest["name"],
+            str(manifest["version"]),
+            publish_slug,
+        )
+        manifest["pack_uri"] = pack_uri
+    else:
+        manifest["type"] = "published"
+
+    with open(manifest_location, "w") as f:
+        yaml.safe_dump(env, f)
+    if pack_size > 100:
+        MultiPartUploader(
+            pack_file, pack_uri, 10, oci_config, oci_profile, auth_type
+        ).upload(manifest)
+    else:
+        with open(pack_file, "rb") as pkf:
+            client.put_object(
+                ns,
+                bucket,
+                manifest["pack_path"],
+                pkf,
+                opc_meta={"manifest": json.dumps(manifest)},
+            )
+    print(f"Conda pack {pack_uri} published.")
+    os.remove(pack_file)