#compdef conda mamba micromamba
#description:conda package manager
#
# ZSH Completion for conda (http://conda.pydata.org/)
#
# Author: Valentin Haenel <valentin@haenel.co> (https://github.com/esc/)
# Licence: WTFPL (http://sam.zoy.org/wtfpl/)
# Version: 0.11
# Homepage: https://github.com/conda-incubator/conda-zsh-completion
# Demo: https://asciinema.org/a/16516
#
# This completion depends on Python for a json parser, sorry. Unfortunately
# there is no such thing in zsh (yet).
#
# To use this completion, install it somewhere on your hard drive:
#
# $ git clone https://github.com/conda-incubator/conda-zsh-completion
#
# And then add it to your $fpath in ~/.zshrc before you call compinit:
#
# fpath+=/path/to/where/you/installed/conda-zsh-completion
# compinit
#
# If you're using oh-my-zsh or Prezto, they will call compinit for you, so
# just add it to your $fpath before calling the OMZ or Prezto initialization
# functions. For example:
#
# git clone https://github.com/conda-incubator/conda-zsh-completion ${ZSH_CUSTOM:=~/.oh-my-zsh/custom}/plugins/conda-zsh-completion
#
# And add lines in `.zshrc`
# plugins=(… conda-zsh-completion)
# autoload -U compinit && compinit
#
# If you're using zim(Zsh IMproved), you must add it before `zmodule completion` to `.zimrc`,
# completion zmodule will call compinit for you, `.zimrc` should like this:
#
# …
# zmodule conda-incubator/conda-zsh-completion
# zmodule completion
# …
#
# and then run `zimfw install -v && exec zsh`
#
# If you use oh-my-zsh, you might have to move the "autoload" line to after you sourced
# oh-my-zsh.sh.
#
# To activate the completion cache for packages, add the following to your
# '.zshrc':
#
# zstyle ':completion::complete:*' use-cache 1
#
# Note: this is IMPORTANT to activate! Otherwise the completion will appear to
# hang when attempting to complete package names when using `conda install` as
# the completion will attempt to fetch the list of ALL available packages from
# anaconda.org. This may take 10s of seconds and the completion looks like it
# 'hangs' while doing so.
#
# To display subcommand completion in groups, please add the following to your
# '.zshrc':
#
# zstyle ":conda_zsh_completion:*" use-groups true
#
# To display unnamed environments and prefixes of environments, add the following
# to your '.zshrc':
#
# zstyle ":conda_zsh_completion:*" show-unnamed true
#
# To display environments autocompletion sorted in creation order add the following
# to your '.zshrc':
#
# zstyle ":conda_zsh_completion:*" sort-envs-by-time true
#
# The completion will display both global environments (envs located in conda_dir/envs and base env)
# and local environments (located in ~/.conda/envs).
# If enables sort-envs-by-time, it will display local environments first.
# To display global environments first, add the following to your '.zshrc':
#
# zstyle ":conda_zsh_completion:*" show-global-envs-first true
#
# If not enables sort-envs-by-time, then all environments will be sorted by alphabetical order,
# and this option is useless.
#
# To forcefully clean the completion cache, look in '~/.zcompcache' and remove
# file starting with 'conda_'. And/or do 'rm ~/.zcompdump*'.
#
# When developing, you can use the following to reload the completion after
# having modified it:
#
# $ unfunction _conda && autoload -U _conda
#
# Please report any issues at:
# https://github.com/conda-incubator/conda-zsh-completion/issues
#
# CHANGELOG
# ---------
#
# * v0.12
#
# * update conda search completion (#62 esc)
# * Conda info: removed arg package (#61 Hanspe-3019)
#
# * v0.11
#
# * fix repo url in doc (esc)
# * ignore `KeyboardInterrupt` exception (rmekdma)
# * Fix completion of dir local prefixed environments (johannes-mueller)
# * Set initial value outside of local. (hwalinga)
# * Update repository URL (dstansby)
# * Add micromamba naive support (antony-frolov)
#
# * v0.10
#
# * Search environments in custom environments paths, thanks to Thomas G. (coldfix).
# * Naive mamba support, thanks to olegtarasov
# * Remove path prefix from environments in default location, thanks to 3mb3dw0rk5
# * Sort environments to be completed by creation time, thanks to m-novikov
# * Check for environment directory before accessing, thanks to huyz-git
#
# * v0.9
#
# * Improved the completion speed for completing environments, thanks to
# Niels Mündler.
# * Various minor improvements and documentation upgrades
#
# * v0.8
#
# * Updated installation instructions and added a license file, thanks to
# Andrew Janke
#
# * v0.7
#
# * Fix alignment during menu-completion
#
# * v0.6
#
# * conda activate and conda deactivate can now be completed, thanks to
# Taylor Kang Beck
#
# * v0.5
#
# * conda-env can now be completed
# * conda-build can now be completed
#
# * v0.4
#
# * conda info can complete available packages
# * conda install and create have rudimentary package version completion
# * remove caching for local package list, it's fast enough
# * conda remove and update are aware of -n or similar and complete only
# packages in the given environment
# * list of packages excludes those installed with pip
#
# * v0.3
#
# * overhaul of the completion for config
#
# * complete only existing keys
# * complete only existing values
# * differentiate between list and boolean config
# * reader and writer options mutually exclusive
# * complete multiple keys for --get
#
# * -n,--name and -p,--prefix are now mutually exclusive
#
# * v0.2
#
# * completion cache for packages
# * complete all channels defined in .condarc
#
# * v0.1
#
# * inital release
#
# TODO
# ----
#
# * Subcommand grouping is still alpha.
# * Example of activating cache only for conda completion
# * Make cache policy configurable
# * Completion for version numbers is rudimentary:
# only 'install' can complete them and only for a single '=' sign
# * Configuration for external commands: only build and env supported
# * Properly handle package specs on the command line
# * Don't continue to complete options once -- is given
# * None of the commands are aware of channels
local state line context
local -A opt_args
__conda_envs(){
local -a envs unnamed sort globalfirst localenvs globalenvs
local -a conda_path
local -a ls_opts
local -a describe_opts
local localenvspath
# only parse environments.txt (including unnamed envs) if asked by the user
zstyle -s ":conda_zsh_completion:*" show-unnamed unnamed
zstyle -s ":conda_zsh_completion:*" sort-envs-by-time sort
zstyle -s ":conda_zsh_completion:*" show-global-envs-first globalfirst
ls_opts=("-1")
if test -n "$sort"; then
ls_opts+=("-t")
describe_opts+=("-V")
fi
conda_exec=$(which conda)
# Detect homebrew installations and set path accordingly.
if [[ ${${conda_exec}#*"homebrew"} != ${conda_exec} ]]; then
conda_path="/opt/homebrew/Caskroom/miniconda/base/envs"
else
conda_path="${${CONDA_EXE}%bin/conda}/envs"
fi
# global envs (if exists) and base env.
globalenvs=($([[ -d "${conda_path}" ]] && ls $ls_opts ${conda_path}))
globalenvs+=("base")
# local envs (if exists).
if [[ -n "$CONDA_ENVS_PATH" ]]; then
localenvspath="$CONDA_ENVS_PATH"
elif [[ -n "$CONDA_ENVS_DIRS" ]]; then
localenvspath="$CONDA_ENVS_DIRS"
else
localenvspath="${HOME:?}/.conda/envs"
fi
localenvs=($([[ -d "$localenvspath" ]] && ls $ls_opts "$localenvspath"))
if test -n "$globalfirst"; then
envs=($globalenvs $localenvs)
else
envs=($localenvs $globalenvs)
fi
# unmaned envs (if show-unammed).
if test -n "$unnamed"; then
envs+=($( (cat ${HOME:?}/.conda/environments.txt) 2>/dev/null | cut -f1 -d' ' | sed -e "s|^${PWD}|.|" | sed -e "s|^$localenvspath/||"))
fi
_describe $describe_opts -t envs 'conda environments' envs
}
__conda_packages_installed(){
local -a installed_packages option environment additional_message
# check for command line overrides
[[ -n "$1" ]] && option="$1"
[[ -n "$2" ]] && environment="$2"
installed_packages=($( conda list --no-pip $option $environment | sed 1,2d | cut -f1 -d' ' ))
[[ -n $option ]] && [[ -n $environment ]] && additional_message=" in environment: '$environment'"
_describe -t installed_packages "installed packages$additional_message" installed_packages
}
__conda_package_available(){
zstyle ":completion:${curcontext}:" cache-policy __conda_caching_policy
local -a available_packages
if _cache_invalid conda_available_packages || ! _retrieve_cache conda_available_packages ; then
available_packages=($(conda search --use-index-cache --json |
python -c "
import json, sys
parsed = json.load(sys.stdin)
try:
for k in parsed.keys():
print(k)
except KeyboardInterrupt:
pass
"))
_store_cache conda_available_packages available_packages
fi
print -l $available_packages
}
__describe_conda_package_available(){
local -a available_packages
available_packages=($( __conda_package_available))
_describe -t available_packages 'available packages' available_packages
}
__conda_existing_config_keys(){
local -a config_keys
config_keys=($(conda config --json --get |
python -c "
import json, sys
keys = json.load(sys.stdin)['get'].keys()
try:
for k in keys:
print(k)
except KeyboardInterrupt:
pass
"))
print -l $config_keys
}
__conda_describe_existing_config_keys(){
local -a config_keys
config_keys=($( __conda_existing_config_keys ))
if [ "${#config_keys}" == 0 ] ; then
_message "no keys found!"
else
_describe -t config_keys 'existing configuration keys' config_keys
fi
}
__conda_describe_existing_list_config_keys(){
local -a config_keys existing_list_config_keys
config_keys=($( __conda_existing_config_keys ))
existing_list_config_keys=()
for k in $config_keys; do
if (( ${__conda_list_config_keys[(I)$k]} )) ; then
existing_list_config_keys+=$k
fi
done
if [ "${#existing_list_config_keys}" == 0 ] ; then
_message "no keys found!"
else
_describe -t existing_list_config_keys 'existing list configuration keys' existing_list_config_keys
fi
}
__conda_existing_config_values(){
local -a config_values search_term
search_term="$1"
config_values=($(conda config --json --get "$search_term" 2> /dev/null |
python -c "
import json, sys
try:
values = json.load(sys.stdin)['get']['$search_term']
for v in values:
print(v)
except (KeyError, VlaueError, KeyboardInterrupt):
pass
"))
print -l $config_values
}
__conda_describe_existing_config_values(){
local -a config_values search_term
search_term="$1"
config_values=($( __conda_existing_config_values $search_term ))
if [ "${#config_values}" == 0 ] ; then
_message "no values found for '$search_term'!"
else
_describe -t config_values 'configuration values' config_values
fi
}
__conda_describe_boolean_config_values(){
local -a config_values
config_values=(True False)
_describe -t config_values 'boolean configuration values' config_values
}
__conda_channels(){
local -a channels
channels=($( __conda_existing_config_values "channels" ))
channels+=(system)
_describe -t channels 'conda channels' channels
}
local -a __conda_boolean_config_keys __conda_list_config_keys __conda_config_keys
__conda_boolean_config_keys=(
'add_binstar_token'
'always_yes'
'allow_softlinks'
'changeps1'
'use_pip'
'offline'
'binstar_upload'
'binstar_personal'
'show_channel_urls'
'allow_other_channels'
'ssl_verify'
)
__conda_list_config_keys=(
'channels'
'disallow'
'create_default_packages'
'track_features'
'envs_dirs'
)
__conda_config_keys=($__conda_boolean_config_keys $__conda_list_config_keys)
__conda_describe_boolean_config_keys(){
_describe -t __conda_boolean_config_keys 'boolean keys' __conda_boolean_config_keys
}
__conda_describe_list_config_keys(){
_describe -t __conda_list_config_keys 'list keys' __conda_list_config_keys
}
__conda_describe_config_keys(){
_describe -t __conda_config_keys 'conda configuration keys' __conda_config_keys
}
#__conda_package_specs=('<' '>' '<=' '>=' '==' '!=')
__conda_package_specs=('=')
__conda_describe_package_specs(){
_describe -t __conda_package_specs 'conda package specs' __conda_package_specs
}
__conda_describe_package_version(){
local -a current_package versions
current_package="$1"
versions=($( conda search --json --use-index-cache $current_package | python -c "
import json,sys
try:
versions = set((e['version'] for e in json.load(sys.stdin)['$current_package']))
for v in versions:
print(v)
except (KeyError, KeyboardInterrupt):
pass
"))
_describe -t versions "$current_package version" versions
}
__conda_commands(){
local -a package maint environment help config special tmp
package=(
search:'Search for packages and display their information.'
install:'Install a list of packages into a specified conda environment.'
)
maint=(
update:'Update conda packages.'
clean:'Remove unused packages and caches.'
)
environment=(
info:'Display information about current conda install.'
create:'Create a new conda environment from a list of specified packages.'
list:'List linked packages in a conda environment.'
remove:'Remove a list of packages from a specified conda environment.'
uninstall:'Alias for conda remove'
activate:'Activate an environment; alias for source activate'
deactivate:'Deactivate an environment; alias for source deactivate'
)
help=(
help:'Displays a list of available conda commands and their help strings.'
)
config=(
config:'Modify configuration values in .condarc.'
)
special=(
run:'Launches an application installed with Conda.'
init:'Initialize conda into a regular environment. (EXPERIMENTAL)'
package:'Low-level conda package utility. (EXPERIMENTAL)'
bundle:'Create or extract a "bundle package" (EXPERIMENTAL)'
)
external=(
env:'Manage environments.'
build:'tool for building conda packages'
)
# This takes care of alignment if the user wanted the subcommand completion
# to be split into groups.
zstyle -s ":conda_zsh_completion:*" use-groups tmp
if [[ -n $tmp ]] ; then
_describe -t package_commands "package commands" package
_describe -t maint_commands "maint commands" maint
_describe -t environment_commands "environment commands" environment
_describe -t help_commands "help commands" help
_describe -t config_commands "config commands" config
_describe -t special_commands "special commands" special
_describe -t external_commands "external commands" external
else
_describe "conda commands" package -- maint -- environment -- help -- config -- special -- external
fi
}
__conda_caching_policy() {
local -a oldp
oldp=( "$1"(Nmh+12) ) # 12 hour
(( $#oldp ))
}
local -a opts help_opts json_opts env_opts channel_opts install_opts
opts=(
'(-h --help)'{-h,--help}'[show this help message and exit]'
'(-V --version)'{-V,--version}'[show program''s version number and exit]'
)
help_opts=(
'(-h --help)'{-h,--help}'[show this help message and exit]' \
)
json_opts=(
'--json[report all output as json.]' \
)
env_opts=(
'(-n --name -p --prefix)'{-n,--name}'[name of environment]:environment:__conda_envs' \
'(-n --name -p --prefix)'{-p,--prefix}'[full path to environment prefix]:prefix:_directories' \
)
channel_opts=(
'(-c --channel)'{-c,--channel}'[additional channel to search for packages]:channel:__conda_channels'\
'--override-channels [do not search default or .condarc channels]' \
'--use-index-cache[use cache of channel index files]' \
'--use-local[use locally built packages]' \
)
install_opts=(
'(-y --yes)'{-y,--yes}'[do not ask for confirmation]' \
'--dry-run[only display what would have been done]' \
'(-f --force)'{-f,--force}'[force install]' \
'--file[read package versions from file]:file:_path_files' \
'--no-deps[do not install dependencies]' \
'(-m --mkdir)'{-m,--mkdir}'[create prefix directory if necessary]' \
'--offline[offline mode, don''t connect to internet]' \
'--no-pin[ignore pinned file]' \
'(-q --quiet)'{-q,--quiet}'[do not display progress bar]'\
'--copy[Install all packages using copies instead of hard- or soft-linking]' \
'--alt-hint[Use an alternate algorithm to generate an unsatisfiable hint]' \
)
_arguments -C $opts \
': :->command' \
'*:: :->subcmd'
# the magic function, complete either a package or a package and it's version
__magic(){
local -a last_item available_packages current_package
last_item=$line[$CURRENT]
available_packages=($( __conda_package_available ))
if compset -P "*=" ; then
current_package="$IPREFIX[1,-2]"
__conda_describe_package_version $current_package
else
__describe_conda_package_available
if [[ -n $last_item ]] && (( ${available_packages[(I)$last_item]} )); then
compset -P '*'
__conda_describe_package_specs
fi
fi
}
case $state in
(command)
__conda_commands
;;
(subcmd)
case ${line[1]} in
(info)
_arguments -C $help_opts \
'--json[report all output as json.]' \
'(-a --all)'{-a,--all}'[show all information, (environments, license, and system information]' \
'(-e --envs)'{-e,--envs}'[list all known conda environments]' \
'(-l --license)'{-l,--license}'[display information about local conda licenses list]' \
'(-s --system)'{-s,--system}'[list environment variables]' \
'--root[display root environment path]' \
;;
(help)
_arguments -C $help_opts \
'*:commands:__conda_commands' \
;;
(list)
_arguments -C $help_opts \
$env_opts \
$json_opts \
'(-c --canonical)'{-c,--canonical}'[output canonical names of packages only]' \
'(-e --export)'{-e,--export}'[output requirement string only]' \
'(-r --revisions)'{-r,--revision}'[list the revision history and exit]' \
'--no-pip[Do not include pip-only installed packages]' \
'*:regex:' \
;;
(search)
_arguments -C $help_opts \
$env_opts \
$json_opts \
$channel_opts \
'(-c --canonical)'{-c,--canonical}'[output canonical names of packages only]' \
'--unknown[use index metadata from the local package cache]' \
'(-o --outdated)'{-o,--outdated}'[only display installed but outdated packages]' \
'(-v --verbose)'{-v,--verbose}'[Show available packages as blocks of data]' \
'--platform[Search the given platform.]' \
'--spec[Treat regex argument as a package specification]' \
'(-i --info)'{-v,--verbose}'[Provide detailed information about each package.]' \
'*:regex:' \
;;
(create)
_arguments -C $help_opts \
$env_opts \
$install_opts \
$json_opts \
$channel_opts \
'--unknown[use index metadata from the local package cache]' \
'--clone[path to (or name of) existing local environment]' \
'--no-default-packages[ignore create_default_packages in condarc file]' \
'*:packages:__magic' \
;;
(install)
_arguments -C $help_opts \
$env_opts \
$install_opts \
$json_opts \
$channel_opts \
'--revision[revert to the specified revision]:revision' \
'*:packages:__magic' \
;;
(update)
local -a environment options specifier
options=('-n' '--name' '-p' '--prefix')
for i in $options ; do
(( ${line[(I)$i]} )) && specifier=$i
done
[[ -n $specifier ]] && environment="$line[${line[(i)$specifier]}+1]"
_arguments -C $help_opts \
$env_opts \
$install_opts \
$json_opts \
$channel_opts \
'--unknown[use index metadata from the local package cache]' \
'--all[Update all installed packages in the environment]' \
'*:packages:{__conda_packages_installed $specifier $environment}' \
;;
(remove|uninstall)
local -a environment options specifier
options=('-n' '--name' '-p' '--prefix')
for i in $options ; do
(( ${line[(I)$i]} )) && specifier=$i
done
[[ -n $specifier ]] && environment="$line[${line[(i)$specifier]}+1]"
_arguments -C $help_opts \
$env_opts \
$json_opts \
$channel_opts \
'(-y --yes)'{-y,--yes}'[do not ask for confirmation]' \
'--dry-run[only display what would have been done]' \
'(-a --all)'{-a,--all}'[remove all packages, i.e. the entire environment]' \
'--features[remove features (instead of packages)]' \
'--no-pin[ignore pinned file]' \
'(-q --quiet)'{-q,--quiet}'[do not display progress bar]'\
'--offline[offline mode, don''t connect to internet]' \
'*:packages:{__conda_packages_installed $specifier $environment}' \
;;
(config)
# this allows completing multiple keys when --get is given
local -a last_item get_opts
last_item=$line[$CURRENT-1]
if (( ${line[(I)--get]} )) && (( ${__conda_config_keys[(I)$last_item]} )) ; then
get_opts=('*:keys:__conda_describe_existing_config_keys')
else
get_opts=''
fi
_arguments -C $help_opts \
$json_opts \
'--system[write to the system .condarc file]' \
'--file[write to the given file.]:file:_path_files' \
'( --add --set --remove --remove-key)--get[get the configuration value]:key:__conda_describe_existing_config_keys' \
'(--get --set --remove --remove-key)--add[add one configuration value to a list key]:list key:__conda_describe_list_config_keys:value:' \
'(--get --add --remove --remove-key)--set[set a boolean key]:boolean key:__conda_describe_boolean_config_keys:value:__conda_describe_boolean_config_values' \
'(--get --add --set --remove-key)--remove[remove a configuration value from a list key]:list key:__conda_describe_existing_list_config_keys:value:{__conda_describe_existing_config_values '$last_item'}' \
'(--get --add --set --remove )--remove-key[remove a configuration key (and all its values)]:key:__conda_describe_existing_config_keys' \
'(-f --force)'{-f,--force}'[write to the config file using the yaml parser]' \
$get_opts
;;
(init)
_arguments -C $help_opts \
;;
(clean)
_arguments -C $help_opts \
$json_opts \
'(-y --yes)'{-y,--yes}'[do not ask for confirmation]' \
'--dry-run[only display what would have been done]' \
'(-i --index-cache)'{-i,--index-cache}'[remove index cache]' \
'(-l --lock)'{-l,--lock}'[remove all conda lock files]' \
'(-t --tarballs)'{-t,--tarballs}'[remove cached package tarballs]' \
'(-p --packages)'{-p,--packages}'[remove unused cached packages]' \
'(-s --source-cache)'{-s,--source-cache}'[remove files from the source cache of conda build]' \
;;
(package)
_arguments -C $help_opts \
$env_opts \
'(-w --which)'{-w,--which}'[given some path print which conda package the file came from]:path:_path_files' \
'(-L --ls-files)'{-L,--ls-files}'[list all files belonging to specified package]' \
'(-r --reset)'{-r,--reset}'[remove all untracked files and exit]' \
'(-u --untracked)'{-u,--untracked}'[display all untracked files and exit]' \
'--pkg-name[package name of the created package]:pkg_name:' \
'--pkg-version[package version of the created package]:pkg_version:' \
'--pkg-build[package build number of the created package]:pkg_build:' \
;;
(bundle)
_arguments -C $help_opts \
$env_opts \
$json_opts \
'(-c --create)'{-c,--create}'[create bundle]' \
'(-x --extract)'{-x,--extract}'[extact bundle located at path]:path:_path_files' \
'--metadump[dump metadata of bundle at path]:path:_path_files' \
'(-q --quiet)'{-q,--quiet}'[do not display progress bar]'\
'--bundle-name[name of bundle]:NAME:' \
'--data-path[path to data to be included in bundle]:path:_path_files' \
'--extra-meta[path to json file with additional meta-data no]:path:_path_files' \
'--no-env[no environment]' \
;;
(build)
_arguments -C $help_opts \
'(-c --check)'{-c,--check}'[only check (validate) the recipe]' \
'--no-binstar-upload[do not ask to upload the package to binstar]' \
'--output[output the conda package filename which would have been created and exit]' \
'(-s --source)'{-s,--source}'[only obtain the source (but don''t build)]' \
'(-t --test)'{-t,--test}'[test package (assumes package is already build)]' \
'--no-test[do not test the package]' \
'(-b --build-only)'{-b,--build-only}'[only run the build, without any post processing or testing]' \
'(-p --post)'{-p,--post}'[run the post-build logic]' \
'(-V --version)'{-V,--version}'[show program''s version number and exit]' \
'(-q --quiet)'{-q,--quiet}'[do not display progress bar]' \
'--python[Set the Python version used by conda build]' \
'--perl[Set the Perl version used by conda build]' \
'--numpy[Set the NumPy version used by conda build]' \
'*:recipe_path:_path_files' \
;;
(env)
_arguments -C $opts \
': :->command' \
'*:: :->subcmd'
case $state in
(command)
local -a env
env=(
create:'Create an environment based on an environment file'
export:'Export a given environment'
list:'List the Conda environments'
remove:'Remove an environment'
update:'Update the current environment based on environment file'
)
_describe -t env_commands "help commands" env
;;
(subcmd)
case ${line[1]} in
(create)
_arguments -C $help_opts \
$json_opts \
$env_opts \
'(-f --file)'{-f,--file}'[environment definition]:file:_path_files' \
'(-q --quiet)'{-q,--quiet}'[]' \
;;
(export)
_arguments -C $help_opts \
$env_opts \
'(-f --file)'{-f,--file}'[]:file:_path_files' \
;;
(list)
_arguments -C $help_opts \
$json_opts \
$env_opts
;;
(remove)
_arguments -C $help_opts \
$json_opts \
$env_opts \
'(-q --quiet)'{-q,--quiet}'[do not display progress bar]'\
'(-y --yes)'{-y,--yes}'[do not ask for confirmation]' \
'--dry-run[only display what would have been done]' \
;;
(update)
_arguments -C $help_opts \
$json_opts \
$env_opts \
'(-f --file)'{-f,--file}'[environment definition]:file:_path_files' \
'(-q --quiet)'{-q,--quiet}'[]' \
;;
esac
;;
esac
;;
(activate)
_arguments -C $help_opts \
'--stack[activate this environment on top of the previous environment]' \
'*:environment:{__conda_envs; _directories}'
;;
(deactivate)
_arguments -C $help_opts \
;;
esac
;;
esac