text: """
  condacolab
  Install Conda and friends on Google Colab, easily
  
  Usage:
  
  >>> import condacolab
  >>> condacolab.install()
  
  For more details, check the docstrings for ``install_from_url()``.
  """
  
  import os
  import sys
  import shutil
  from datetime import datetime, timedelta
  from pathlib import Path
  from subprocess import run, PIPE, STDOUT
  from typing import Dict, AnyStr
  from urllib.request import urlopen
  from distutils.spawn import find_executable
  
  from IPython import get_ipython
  
  
  __version__ = "0.1.3"
  __author__ = "Jaime Rodríguez-Guerra <jaimergp@users.noreply.github.com>"
  
  
  PREFIX = "/usr/local"
  
  
  def install_from_url(
      installer_url: AnyStr,
      prefix: os.PathLike = PREFIX,
      env: Dict[AnyStr, AnyStr] = None,
      run_checks: bool = True,
  ):
      """
      Download and run a constructor-like installer, patching
      the necessary bits so it works on Colab right away.
  
      This will restart your kernel as a result!
  
      Parameters
      ----------
      installer_url
          URL pointing to a ``constructor``-like installer, such
          as Miniconda or Mambaforge
      prefix
          Target location for the installation
      env
          Environment variables to inject in the kernel restart.
          We *need* to inject ``LD_LIBRARY_PATH`` so ``{PREFIX}/lib``
          is first, but you can also add more if you need it. Take
          into account that no quote handling is done, so you need
          to add those yourself in the raw string. They will
          end up added to a line like ``exec env VAR=VALUE python3...``.
          For example, a value with spaces should be passed as::
  
              env={"VAR": '"a value with spaces"'}
      run_checks
          Run checks to see if installation was run previously.
          Change to False to ignore checks and always attempt
          to run the installation.
      """
      if run_checks:
          try:  # run checks to see if it this was run already
              return check(prefix)
          except AssertionError:
              pass  # just install
  
      t0 = datetime.now()
      print(f"⏬ Downloading {installer_url}...")
      installer_fn = "__installer__.sh"
      with urlopen(installer_url) as response, open(installer_fn, "wb") as out:
          shutil.copyfileobj(response, out)
  
      print("📦 Installing...")
      task = run(
          ["bash", installer_fn, "-bfp", str(prefix)],
          check=False,
          stdout=PIPE,
          stderr=STDOUT,
          text=True,
      )
      os.unlink(installer_fn)
      with open("condacolab_install.log", "w") as f:
          f.write(task.stdout)
      assert (
          task.returncode == 0
      ), "💥💔💥 The installation failed! Logs are available at `/content/condacolab_install.log`."
  
      print("📌 Adjusting configuration...")
      cuda_version = ".".join(os.environ.get("CUDA_VERSION", "*.*.*").split(".")[:2])
      prefix = Path(prefix)
      condameta = prefix / "conda-meta"
      condameta.mkdir(parents=True, exist_ok=True)
      pymaj, pymin = sys.version_info[:2]
  
      with open(condameta / "pinned", "a") as f:
          f.write(f"python {pymaj}.{pymin}.*\n")
          f.write(f"python_abi {pymaj}.{pymin}.* *cp{pymaj}{pymin}*\n")
          f.write(f"cudatoolkit {cuda_version}.*\n")
  
      with open(prefix / ".condarc", "a") as f:
          f.write("always_yes: true\n")
  
      with open("/tmp/vessl/jupyter_config.py", "a") as f:
          f.write(
              f"""\nc.InteractiveShellApp.exec_lines = [
                      "import sys",
                      "sp = f'{prefix}/lib/python{pymaj}.{pymin}/site-packages'",
                      "if sp not in sys.path:",
                      "    sys.path.insert(0, sp)",
                  ]
              """
          )
      sitepackages = f"{prefix}/lib/python{pymaj}.{pymin}/site-packages"
      if sitepackages not in sys.path:
          sys.path.insert(0, sitepackages)
  
      print("🩹 Patching environment...")
      env = env or {}
      bin_path = f"{prefix}/bin"
      if bin_path not in os.environ.get("PATH", "").split(":"):
          env["PATH"] = f"{bin_path}:{os.environ.get('PATH', '')}"
      env["LD_LIBRARY_PATH"] = f"{prefix}/lib:{os.environ.get('LD_LIBRARY_PATH', '')}"
  
      os.rename(sys.executable, f"{sys.executable}.real")
      with open(sys.executable, "w") as f:
          f.write("#!/bin/bash\n")
          envstr = " ".join(f"{k}={v}" for k, v in env.items())
          f.write(f"exec env {envstr} {sys.executable}.real -x $@\n")
      run(["chmod", "+x", sys.executable])
  
      taken = timedelta(seconds=round((datetime.now() - t0).total_seconds(), 0))
      print(f"⏲ Done in {taken}")
  
      print("🔁 Restarting kernel...")
      get_ipython().kernel.do_shutdown(True)
  
  
  def install_mambaforge(
      prefix: os.PathLike = PREFIX, env: Dict[AnyStr, AnyStr] = None, run_checks: bool = True
  ):
      """
      Install Mambaforge, built for Python 3.7.
  
      Mambaforge consists of a Miniconda-like distribution optimized
      and preconfigured for conda-forge packages, and includes ``mamba``,
      a faster ``conda`` implementation.
  
      Unlike the official Miniconda, this is built with the latest ``conda``.
  
      Parameters
      ----------
      prefix
          Target location for the installation
      env
          Environment variables to inject in the kernel restart.
          We *need* to inject ``LD_LIBRARY_PATH`` so ``{PREFIX}/lib``
          is first, but you can also add more if you need it. Take
          into account that no quote handling is done, so you need
          to add those yourself in the raw string. They will
          end up added to a line like ``exec env VAR=VALUE python3...``.
          For example, a value with spaces should be passed as::
  
              env={"VAR": '"a value with spaces"'}
      run_checks
          Run checks to see if installation was run previously.
          Change to False to ignore checks and always attempt
          to run the installation.
      """
      installer_url = r"https://github.com/jaimergp/miniforge/releases/latest/download/Mambaforge-colab-Linux-x86_64.sh"
      install_from_url(installer_url, prefix=prefix, env=env, run_checks=run_checks)
  
  
  # Make mambaforge the default
  install = install_mambaforge
  
  
  def install_miniforge(
      prefix: os.PathLike = PREFIX, env: Dict[AnyStr, AnyStr] = None, run_checks: bool = True
  ):
      """
      Install Mambaforge, built for Python 3.7.
  
      Mambaforge consists of a Miniconda-like distribution optimized
      and preconfigured for conda-forge packages.
  
      Unlike the official Miniconda, this is built with the latest ``conda``.
  
      Parameters
      ----------
      prefix
          Target location for the installation
      env
          Environment variables to inject in the kernel restart.
          We *need* to inject ``LD_LIBRARY_PATH`` so ``{PREFIX}/lib``
          is first, but you can also add more if you need it. Take
          into account that no quote handling is done, so you need
          to add those yourself in the raw string. They will
          end up added to a line like ``exec env VAR=VALUE python3...``.
          For example, a value with spaces should be passed as::
  
              env={"VAR": '"a value with spaces"'}
      run_checks
          Run checks to see if installation was run previously.
          Change to False to ignore checks and always attempt
          to run the installation.
      """
      installer_url = r"https://github.com/jaimergp/miniforge/releases/latest/download/Miniforge-colab-Linux-x86_64.sh"
      install_from_url(installer_url, prefix=prefix, env=env, run_checks=run_checks)
  
  
  def install_miniconda(
      prefix: os.PathLike = PREFIX, env: Dict[AnyStr, AnyStr] = None, run_checks: bool = True
  ):
      """
      Install Miniconda 4.9.2 for Python 3.7.
  
      Parameters
      ----------
      prefix
          Target location for the installation
      env
          Environment variables to inject in the kernel restart.
          We *need* to inject ``LD_LIBRARY_PATH`` so ``{PREFIX}/lib``
          is first, but you can also add more if you need it. Take
          into account that no quote handling is done, so you need
          to add those yourself in the raw string. They will
          end up added to a line like ``exec env VAR=VALUE python3...``.
          For example, a value with spaces should be passed as::
  
              env={"VAR": '"a value with spaces"'}
      run_checks
          Run checks to see if installation was run previously.
          Change to False to ignore checks and always attempt
          to run the installation.
      """
      installer_url = r"https://repo.anaconda.com/miniconda/Miniconda3-py37_4.9.2-Linux-x86_64.sh"
      install_from_url(installer_url, prefix=prefix, env=env, run_checks=run_checks)
  
  
  def install_anaconda(
      prefix: os.PathLike = PREFIX, env: Dict[AnyStr, AnyStr] = None, run_checks: bool = True
  ):
      """
      Install Anaconda 2020.02, the last official version built
      for Python 3.7.
  
      Parameters
      ----------
      prefix
          Target location for the installation
      env
          Environment variables to inject in the kernel restart.
          We *need* to inject ``LD_LIBRARY_PATH`` so ``{PREFIX}/lib``
          is first, but you can also add more if you need it. Take
          into account that no quote handling is done, so you need
          to add those yourself in the raw string. They will
          end up added to a line like ``exec env VAR=VALUE python3...``.
          For example, a value with spaces should be passed as::
  
              env={"VAR": '"a value with spaces"'}
      run_checks
          Run checks to see if installation was run previously.
          Change to False to ignore checks and always attempt
          to run the installation.
      """
      installer_url = r"https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh"
      install_from_url(installer_url, prefix=prefix, env=env, run_checks=run_checks)
  
  
  def check(prefix: os.PathLike = PREFIX, verbose: bool = True):
      """
      Run some basic checks to ensure that ``conda`` has been installed
      correctly
  
      Parameters
      ----------
      prefix
          Location where ``conda`` was installed (should match the one
          provided for ``install()``.
      verbose
          Print success message if True
      """
      assert find_executable("conda"), "💥💔💥 Conda not found!"
  
      pymaj, pymin = sys.version_info[:2]
      sitepackages = f"{prefix}/lib/python{pymaj}.{pymin}/site-packages"
      assert sitepackages in sys.path, f"💥💔💥 PYTHONPATH was not patched! Value: {sys.path}"
      assert (
          f"{prefix}/bin" in os.environ["PATH"]
      ), f"💥💔💥 PATH was not patched! Value: {os.environ['PATH']}"
      assert (
          f"{prefix}/lib" in os.environ["LD_LIBRARY_PATH"]
      ), f"💥💔💥 LD_LIBRARY_PATH was not patched! Value: {os.environ['LD_LIBRARY_PATH']}"
      if verbose:
          print("✨🍰✨ Everything looks OK!")
  
  
  __all__ = [
      "install",
      "install_from_url",
      "install_mambaforge",
      "install_miniforge",
      "install_miniconda",
      "install_anaconda",
      "check",
      "PREFIX",
  ]
  