if [ -n "${ZSH_VERSION:-}" ]

then

builtin \cd -q "$@"

else

builtin \cd "$@"

fi

if [ "$1" = "" ]; then

return 1

else

"$VIRTUALENVWRAPPER_PYTHON" -c "import os,sys; sys.stdout.write(os.path.normpath(os.path.expanduser(os.path.expandvars(\"$1\")))+'\n')"

return 0

fi

if [ "$1" = "" ]; then

return 1

else

"$VIRTUALENVWRAPPER_PYTHON" -c "import os,sys; sys.stdout.write(os.path.abspath(\"$1\")+'\n')"

return 0

fi

typeset workon_home_dir="$WORKON_HOME"

# Make sure there is a default value for WORKON_HOME.

# You can override this setting in your .bashrc.

if [ "$workon_home_dir" = "" ]

then

workon_home_dir="$HOME/.virtualenvs"

fi

# If the path is relative, prefix it with $HOME

# (note: for compatibility)

if echo "$workon_home_dir" | (unset GREP_OPTIONS; command \grep '^[^/~]' > /dev/null)

then

workon_home_dir="$HOME/$WORKON_HOME"

fi

# Only call on Python to fix the path if it looks like the

# path might contain stuff to expand.

# (it might be possible to do this in shell, but I don't know a

# cross-shell-safe way of doing it -wolever)

if echo "$workon_home_dir" | (unset GREP_OPTIONS; command \grep -E '([\$~]|//)' >/dev/null)

then

# This will normalize the path by:

# - Removing extra slashes (e.g., when TMPDIR ends in a slash)

# - Expanding variables (e.g., $foo)

# - Converting ~s to complete paths (e.g., ~/ to /home/brian/ and ~arthur to /home/arthur)

workon_home_dir="$(virtualenvwrapper_expandpath "$workon_home_dir")"

fi

echo "$workon_home_dir"

return 0

RC=0

if [ ! -d "$WORKON_HOME/" ]

then

if [ "$1" != "-q" ]

then

echo "NOTE: Virtual environments directory $WORKON_HOME does not exist. Creating..." 1>&2

fi

mkdir -p "$WORKON_HOME"

RC=$?

fi

return $RC

# Note: the 'X's must come last

typeset suffix=${1:-hook}

typeset file

file="$(virtualenvwrapper_mktemp -t virtualenvwrapper-$suffix-XXXXXXXXXX)"

touch "$file"

if [ $? -ne 0 ] || [ -z "$file" ] || [ ! -f "$file" ]

then

echo "ERROR: virtualenvwrapper could not create a temporary file name." 1>&2

return 1

fi

echo $file

return 0

typeset hook_script

typeset result

hook_script="$(virtualenvwrapper_tempfile ${1}-hook)" || return 1

# Use a subshell to run the python interpreter with hook_loader so

# we can change the working directory. This avoids having the

# Python 3 interpreter decide that its "prefix" is the virtualenv

# if we happen to be inside the virtualenv when we start.

( \

virtualenvwrapper_cd "$WORKON_HOME" &&

"$VIRTUALENVWRAPPER_PYTHON" -m 'virtualenvwrapper.hook_loader' \

${HOOK_VERBOSE_OPTION:-} --script "$hook_script" "$@" \

)

result=$?

if [ $result -eq 0 ]

then

if [ ! -f "$hook_script" ]

then

echo "ERROR: virtualenvwrapper_run_hook could not find temporary file $hook_script" 1>&2

command \rm -f "$hook_script"

return 2

fi

# cat "$hook_script"

source "$hook_script"

elif [ "${1}" = "initialize" ]

then

cat - 1>&2 <<EOF

fi

command \rm -f "$hook_script"

return $result

if [ -n "${BASH:-}" ] ; then

_virtualenvs () {

local cur="${COMP_WORDS[COMP_CWORD]}"

COMPREPLY=( $(compgen -W "`virtualenvwrapper_show_workon_options`" -- ${cur}) )

}

_cdvirtualenv_complete () {

local cur="$2"

COMPREPLY=( $(cdvirtualenv && compgen -d -- "${cur}" ) )

}

_cdsitepackages_complete () {

local cur="$2"

COMPREPLY=( $(cdsitepackages && compgen -d -- "${cur}" ) )

}

complete -o nospace -F _cdvirtualenv_complete -S/ cdvirtualenv

complete -o nospace -F _cdsitepackages_complete -S/ cdsitepackages

complete -o default -o nospace -F _virtualenvs workon

complete -o default -o nospace -F _virtualenvs rmvirtualenv

complete -o default -o nospace -F _virtualenvs cpvirtualenv

complete -o default -o nospace -F _virtualenvs showvirtualenv

elif [ -n "$ZSH_VERSION" ] ; then

_virtualenvs () {

reply=( $(virtualenvwrapper_show_workon_options) )

}

_cdvirtualenv_complete () {

reply=( $(cdvirtualenv && ls -d ${1}*) )

}

_cdsitepackages_complete () {

reply=( $(cdsitepackages && ls -d ${1}*) )

}

compctl -K _virtualenvs workon rmvirtualenv cpvirtualenv showvirtualenv

compctl -K _cdvirtualenv_complete cdvirtualenv

compctl -K _cdsitepackages_complete cdsitepackages

fi

export WORKON_HOME="$(virtualenvwrapper_derive_workon_home)"

virtualenvwrapper_verify_workon_home -q || return 1

# Set the location of the hook scripts

if [ "$VIRTUALENVWRAPPER_HOOK_DIR" = "" ]

then

VIRTUALENVWRAPPER_HOOK_DIR="$WORKON_HOME"

fi

export VIRTUALENVWRAPPER_HOOK_DIR

mkdir -p "$VIRTUALENVWRAPPER_HOOK_DIR"

virtualenvwrapper_run_hook "initialize"

virtualenvwrapper_setup_tab_completion

return 0

typeset exe_path="$(command \which "$1" | (unset GREP_OPTIONS; command \grep -v "not found"))"

if [ "$exe_path" = "" ]

then

echo "ERROR: virtualenvwrapper could not find $1 in your path" >&2

return 1

fi

if [ ! -e "$exe_path" ]

then

echo "ERROR: Found $1 in path as \"$exe_path\" but that does not exist" >&2

return 1

fi

return 0

typeset env_name="$1"

if [ ! -d "$WORKON_HOME/$env_name" ]

then

echo "ERROR: Environment '$env_name' does not exist. Create it with 'mkvirtualenv $env_name'." >&2

return 1

fi

return 0

if [ ! -n "${VIRTUAL_ENV}" ] || [ ! -d "${VIRTUAL_ENV}" ]

then

echo "ERROR: no virtualenv active, or active virtualenv is missing" >&2

return 1

fi

return 0

echo "Usage: mkvirtualenv [-a project_path] [-i package] [-r requirements_file] [-p python_interpreter] [virtualenv options] env_name"

echo

echo " -a project_path"

echo

echo " Provide a full path to a project directory to associate with"

echo " the new environment."

echo

echo " -i package"

echo

echo " Install a package after the environment is created."

echo " This option may be repeated."

echo

echo " -r requirements_file"

echo

echo " Provide a pip requirements file to install a base set of packages"

echo " into the new environment."

echo

echo " -p python_interpreter, --python=python_interpreter"

echo

echo " The Python interpreter to use for the new environment."

echo " This can be specified as -p python3.8 or --python=/path/to/python"

echo

echo;

echo 'virtualenv help:';

echo;

"$VIRTUALENVWRAPPER_VIRTUALENV" $@;

typeset -a in_args

typeset -a out_args

typeset -i i

typeset tst

typeset a

typeset envname

typeset requirements

typeset packages

typeset interpreter

typeset project

in_args=( "$@" )

if [ -n "$ZSH_VERSION" ]

then

i=1

tst="-le"

else

i=0

tst="-lt"

fi

while test $i $tst $#

do

a="${in_args[$i]}"

# echo "arg $i : $a"

case "$a" in

-a)

i=$(( $i + 1 ))

project="${in_args[$i]}"

if [ ! -d "${project}" ]

then

echo "Cannot associate project with $project, it is not a directory" 1>&2

return 1

fi

project="$(virtualenvwrapper_absolutepath ${project})";;

-h|--help)

virtualenvwrapper_mkvirtualenv_help $a;

return;;

-i)

i=$(( $i + 1 ));

packages="$packages ${in_args[$i]}";;

-p|--python*)

if echo "$a" | grep -q "="

then

interpreter="$(echo "$a" | cut -f2 -d=)"

else

i=$(( $i + 1 ))

interpreter="${in_args[$i]}"

fi;;

-r)

i=$(( $i + 1 ));

requirements="${in_args[$i]}";

requirements="$(virtualenvwrapper_expandpath "$requirements")";;

*)

if [ ${#out_args} -gt 0 ]

then

out_args=( "${out_args[@]-}" "$a" )

else

out_args=( "$a" )

fi;;

esac

i=$(( $i + 1 ))

done

if [ ! -z "$interpreter" ]

then

out_args=( "--python=$interpreter" ${out_args[@]} )

fi;

set -- "${out_args[@]}"

eval "envname=\$$#"

virtualenvwrapper_verify_workon_home || return 1

virtualenvwrapper_verify_virtualenv || return 1

(

[ -n "$ZSH_VERSION" ] && setopt SH_WORD_SPLIT

virtualenvwrapper_cd "$WORKON_HOME" &&

"$VIRTUALENVWRAPPER_VIRTUALENV" $VIRTUALENVWRAPPER_VIRTUALENV_ARGS "$@" &&

[ -d "$WORKON_HOME/$envname" ] && \

virtualenvwrapper_run_hook "pre_mkvirtualenv" "$envname"

)

typeset RC=$?

[ $RC -ne 0 ] && return $RC

# If they passed a help option or got an error from virtualenv,

# the environment won't exist. Use that to tell whether

# we should switch to the environment and run the hook.

[ ! -d "$WORKON_HOME/$envname" ] && return 0

# If they gave us a project directory, set it up now

# so the activate hooks can find it.

if [ ! -z "$project" ]

then

setvirtualenvproject "$WORKON_HOME/$envname" "$project"

RC=$?

[ $RC -ne 0 ] && return $RC

fi

# Now activate the new environment

workon "$envname"

if [ ! -z "$requirements" ]

then

pip install -r "$requirements"

fi

for a in $packages

do

pip install $a

done

virtualenvwrapper_run_hook "post_mkvirtualenv"

virtualenvwrapper_verify_workon_home || return 1

if [ ${#@} = 0 ]

then

echo "Please specify an environment." >&2

return 1

fi

# support to remove several environments

typeset env_name

# Must quote the parameters, as environments could have spaces in their names

for env_name in "$@"

do

echo "Removing $env_name..."

typeset env_dir="$WORKON_HOME/$env_name"

if [ "$VIRTUAL_ENV" = "$env_dir" ]

then

echo "ERROR: You cannot remove the active environment ('$env_name')." >&2

echo "Either switch to another environment, or run 'deactivate'." >&2

return 1

fi

if [ ! -d "$env_dir" ]; then

echo "Did not find environment $env_dir to remove." >&2

fi

# Move out of the current directory to one known to be

# safe, in case we are inside the environment somewhere.

typeset prior_dir="$(pwd)"

virtualenvwrapper_cd "$WORKON_HOME"

virtualenvwrapper_run_hook "pre_rmvirtualenv" "$env_name"

command \rm -rf "$env_dir"

virtualenvwrapper_run_hook "post_rmvirtualenv" "$env_name"

# If the directory we used to be in still exists, move back to it.

if [ -d "$prior_dir" ]

then

virtualenvwrapper_cd "$prior_dir"

fi

done

virtualenvwrapper_verify_workon_home || return 1

# NOTE: DO NOT use ls or cd here because colorized versions spew control

# characters into the output list.

# echo seems a little faster than find, even with -depth 3.

# Note that this is a little tricky, as there may be spaces in the path.

#

# 1. Look for environments by finding the activate scripts.

# Use a subshell so we can suppress the message printed

# by zsh if the glob pattern fails to match any files.

# This yields a single, space-separated line containing all matches.

# 2. Replace the trailing newline with a space, so every

# possible env has a space following it.

# 3. Strip the bindir/activate script suffix, replacing it with

# a slash, as that is an illegal character in a directory name.

# This yields a slash-separated list of possible env names.

# 4. Replace each slash with a newline to show the output one name per line.

# 5. Eliminate any lines with * on them because that means there

# were no envs.

(virtualenvwrapper_cd "$WORKON_HOME" && echo */$VIRTUALENVWRAPPER_ENV_BIN_DIR/activate) 2>/dev/null \

| command \tr "\n" " " \

| command \sed "s|/$VIRTUALENVWRAPPER_ENV_BIN_DIR/activate |/|g" \

| command \tr "/" "\n" \

| command \sed "/^[[:space:]]*$/d" \

| (unset GREP_OPTIONS; command \grep -E -v '^\*$') 2>/dev/null

echo "lsvirtualenv [-blh]"

echo " -b -- brief mode"

echo " -l -- long mode"

echo " -h -- this help message"

typeset long_mode=true

if command -v "getopts" >/dev/null 2>&1

then

# Use getopts when possible

OPTIND=1

while getopts ":blh" opt "$@"

do

case "$opt" in

l) long_mode=true;;

b) long_mode=false;;

h) _lsvirtualenv_usage;

return 1;;

?) echo "Invalid option: -$OPTARG" >&2;

_lsvirtualenv_usage;

return 1;;

esac

done

else

# fallback on getopt for other shell

typeset -a args

args=($(getopt blh "$@"))

if [ $? != 0 ]

then

_lsvirtualenv_usage

return 1

fi

for opt in $args

do

case "$opt" in

-l) long_mode=true;;

-b) long_mode=false;;

-h) _lsvirtualenv_usage;

return 1;;

esac

done

fi

if $long_mode

then

allvirtualenv showvirtualenv "$env_name"

else

virtualenvwrapper_show_workon_options

fi

typeset env_name="$1"

if [ -z "$env_name" ]

then

if [ -z "$VIRTUAL_ENV" ]

then

echo "showvirtualenv [env]"

return 1

fi

env_name=$(basename "$VIRTUAL_ENV")

fi

virtualenvwrapper_run_hook "get_env_details" "$env_name"

echo

echo "Usage: workon env_name"

echo ""

echo " Deactivate any currently activated virtualenv"

echo " and activate the named environment, triggering"

echo " any hooks in the process."

echo ""

echo " workon"

echo ""

echo " Print a list of available environments."

echo " (See also lsvirtualenv -b)"

echo ""

echo " workon (-h|--help)"

echo ""

echo " Show this help message."

echo ""

echo " workon (-c|--cd) envname"

echo ""

echo " After activating the environment, cd to the associated"

echo " project directory if it is set."

echo ""

echo " workon (-n|--no-cd) envname"

echo ""

echo " After activating the environment, do not cd to the"

echo " associated project directory."

echo ""

typeset -a in_args

typeset -a out_args

in_args=( "$@" )

if [ -n "$ZSH_VERSION" ]

then

i=1

tst="-le"

else

i=0

tst="-lt"

fi

typeset cd_after_activate=$VIRTUALENVWRAPPER_WORKON_CD

while test $i $tst $#

do

a="${in_args[$i]}"

case "$a" in

-h|--help)

virtualenvwrapper_workon_help;

return 0;;

-n|--no-cd)

cd_after_activate=0;;

-c|--cd)

cd_after_activate=1;;

*)

if [ ${#out_args} -gt 0 ]

then

out_args=( "${out_args[@]-}" "$a" )

else

out_args=( "$a" )

fi;;

esac

i=$(( $i + 1 ))

done

set -- "${out_args[@]}"

typeset env_name="$1"

if [ "$env_name" = "" ]

then

lsvirtualenv -b

return 1

elif [ "$env_name" = "." ]

then

# The IFS default of breaking on whitespace causes issues if there

# are spaces in the env_name, so change it.

IFS='%'

env_name="$(basename $(pwd))"

unset IFS

fi

virtualenvwrapper_verify_workon_home || return 1

virtualenvwrapper_verify_workon_environment "$env_name" || return 1

activate="$WORKON_HOME/$env_name/$VIRTUALENVWRAPPER_ENV_BIN_DIR/activate"

if [ ! -f "$activate" ]

then

echo "ERROR: Environment '$WORKON_HOME/$env_name' does not contain an activate script." >&2

return 1

fi

# Deactivate any current environment "destructively"

# before switching so we use our override function,

# if it exists, but make sure it's the deactivate function

# we set up

! type deactivate >/dev/null 2>&1 || {

typeset -f deactivate | grep 'typeset env_postdeactivate_hook' >/dev/null 2>&1

if [ $? -eq 0 ]

then

deactivate

unset -f deactivate >/dev/null 2>&1

fi

}

virtualenvwrapper_run_hook "pre_activate" "$env_name"

source "$activate"

# Save the deactivate function from virtualenv under a different name

virtualenvwrapper_original_deactivate=`typeset -f deactivate | sed 's/deactivate/virtualenv_deactivate/g'`

eval "$virtualenvwrapper_original_deactivate"

unset -f deactivate >/dev/null 2>&1

# Replace the deactivate() function with a wrapper.

eval 'deactivate () {

VIRTUALENVWRAPPER_PROJECT_CD=$cd_after_activate virtualenvwrapper_run_hook "post_activate"

return 0

# Uses the Python from the virtualenv rather than

# VIRTUALENVWRAPPER_PYTHON because we're trying to determine the

# version installed there so we can build up the path to the

# site-packages directory.

"$VIRTUAL_ENV/$VIRTUALENVWRAPPER_ENV_BIN_DIR/python" -V 2>&1 | cut -f2 -d' ' | cut -f-2 -d.

}

function virtualenvwrapper_get_site_packages_dir {

"$VIRTUAL_ENV/$VIRTUALENVWRAPPER_ENV_BIN_DIR/python" -c "import sysconfig; print(sysconfig.get_path('platlib'))"

}

function add2virtualenv {

virtualenvwrapper_verify_workon_home || return 1

virtualenvwrapper_verify_active_environment || return 1

site_packages="`virtualenvwrapper_get_site_packages_dir`"

if [ ! -d "${site_packages}" ]

then

echo "ERROR: currently-active virtualenv does not appear to have a site-packages directory" >&2

return 1

fi

# Prefix with _ to ensure we are loaded as early as possible,

# and at least before easy_install.pth.

path_file="$site_packages/_virtualenv_path_extensions.pth"

if [ "$*" = "" ]

then

echo "Usage: add2virtualenv dir [dir ...]"

if [ -f "$path_file" ]

then

echo

echo "Existing paths:"

cat "$path_file" | grep -v "^import"

fi

return 1

fi

remove=0

if [ "$1" = "-d" ]

then

remove=1

shift

fi

if [ ! -f "$path_file" ]

then

echo "import sys; sys.__plen = len(sys.path)" > "$path_file" || return 1

echo "import sys; new=sys.path[sys.__plen:]; del sys.path[sys.__plen:]; p=getattr(sys,'__egginsert',0); sys.path[p:p]=new; sys.__egginsert = p+len(new)" >> "$path_file" || return 1

fi

for pydir in "$@"

do

absolute_path="$(virtualenvwrapper_absolutepath "$pydir")"

if [ "$absolute_path" != "$pydir" ]

then

echo "Warning: Converting \"$pydir\" to \"$absolute_path\"" 1>&2

fi

if [ $remove -eq 1 ]

then

sed -i.tmp "\:^$absolute_path$: d" "$path_file"

else

sed -i.tmp '1 a\

' "$path_file"

fi

rm -f "${path_file}.tmp"

done

return 0

virtualenvwrapper_verify_workon_home || return 1

virtualenvwrapper_verify_active_environment || return 1

typeset site_packages="`virtualenvwrapper_get_site_packages_dir`"

virtualenvwrapper_cd "$site_packages/$1"

virtualenvwrapper_verify_workon_home || return 1

virtualenvwrapper_verify_active_environment || return 1

virtualenvwrapper_cd "$VIRTUAL_ENV/$1"

virtualenvwrapper_verify_workon_home || return 1

virtualenvwrapper_verify_active_environment || return 1

typeset site_packages="`virtualenvwrapper_get_site_packages_dir`"

ls $@ "$site_packages"

path_file="$site_packages/_virtualenv_path_extensions.pth"

if [ -f "$path_file" ]

then

echo

echo "_virtualenv_path_extensions.pth:"

cat "$path_file"

fi

virtualenvwrapper_verify_workon_home || return 1

virtualenvwrapper_verify_virtualenv_clone || return 1

typeset src_name="$1"

typeset trg_name="$2"

typeset src

typeset trg

# without a source there is nothing to do

if [ "$src_name" = "" ]; then

echo "Please provide a valid virtualenv to copy."

return 1

else

# see if it's already in workon

if [ ! -e "$WORKON_HOME/$src_name" ]; then

# so it's a virtualenv we are importing

# make sure we have a full path

# and get the name

src="$(virtualenvwrapper_expandpath "$src_name")"

# final verification

if [ ! -e "$src" ]; then

echo "Please provide a valid virtualenv to copy."

return 1

fi

src_name="$(basename "$src")"

else

src="$WORKON_HOME/$src_name"

fi

fi

if [ "$trg_name" = "" ]; then

# target not given, assume

# same as source

trg="$WORKON_HOME/$src_name"

trg_name="$src_name"

else

trg="$WORKON_HOME/$trg_name"

fi

trg="$(virtualenvwrapper_expandpath "$trg")"

# validate trg does not already exist

# catch copying virtualenv in workon home

# to workon home

if [ -e "$trg" ]; then

echo "$trg_name virtualenv already exists."

return 1

fi

echo "Copying $src_name as $trg_name..."

(

[ -n "$ZSH_VERSION" ] && setopt SH_WORD_SPLIT

virtualenvwrapper_cd "$WORKON_HOME" &&

"$VIRTUALENVWRAPPER_VIRTUALENV_CLONE" "$src" "$trg"

[ -d "$trg" ] &&

virtualenvwrapper_run_hook "pre_cpvirtualenv" "$src" "$trg_name" &&

virtualenvwrapper_run_hook "pre_mkvirtualenv" "$trg_name"

)

typeset RC=$?

[ $RC -ne 0 ] && return $RC