# -*- mode: shell-script -*-

#

# Shell functions to act as wrapper for Ian Bicking's virtualenv

# (http://pypi.python.org/pypi/virtualenv)

#

#

# Copyright Doug Hellmann, All Rights Reserved

#

# Permission to use, copy, modify, and distribute this software and its

# documentation for any purpose and without fee is hereby granted,

# provided that the above copyright notice appear in all copies and that

# both that copyright notice and this permission notice appear in

# supporting documentation, and that the name of Doug Hellmann not be used

# in advertising or publicity pertaining to distribution of the software

# without specific, written prior permission.

#

# DOUG HELLMANN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

# EVENT SHALL DOUG HELLMANN BE LIABLE FOR ANY SPECIAL, INDIRECT OR

# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF

# USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR

# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

# PERFORMANCE OF THIS SOFTWARE.

#

#

# Project home page: http://www.doughellmann.com/projects/virtualenvwrapper/

#

#

# Setup:

#

# 1. Create a directory to hold the virtual environments.

# (mkdir $HOME/.virtualenvs).

# 2. Add a line like "export WORKON_HOME=$HOME/.virtualenvs"

# to your .bashrc.

# 3. Add a line like "source /path/to/this/file/virtualenvwrapper.sh"

# to your .bashrc.

# 4. Run: source ~/.bashrc

# 5. Run: workon

# 6. A list of environments, empty, is printed.

# 7. Run: mkvirtualenv temp

# 8. Run: workon

# 9. This time, the "temp" environment is included.

# 10. Run: workon temp

# 11. The virtual environment is activated.

#

# Locate the global Python where virtualenvwrapper is installed.

if [ "${VIRTUALENVWRAPPER_PYTHON:-}" = "" ]

then

_virtualenvwrapper_python_executable="$(which python3 2>/dev/null)"

if [ -n "$_virtualenvwrapper_python_executable" ] && $_virtualenvwrapper_python_executable -m 'virtualenvwrapper.hook_loader' --help >/dev/null 2>&1

then

VIRTUALENVWRAPPER_PYTHON=$_virtualenvwrapper_python_executable

fi

fi

if [ "${VIRTUALENVWRAPPER_PYTHON:-}" = "" ]

then

echo -e "ERROR: Python with virtualenvwrapper module not found!

Either, install virtualenvwrapper module for the default python3 interpreter

or set VIRTUALENVWRAPPER_PYTHON to the interpreter to use." 1>&2

return 1

fi

# Set the name of the virtualenv app to use.

if [ "${VIRTUALENVWRAPPER_VIRTUALENV:-}" = "" ]

then

VIRTUALENVWRAPPER_VIRTUALENV="virtualenv"

fi

# Set the name of the virtualenv-clone app to use.

if [ "${VIRTUALENVWRAPPER_VIRTUALENV_CLONE:-}" = "" ]

then

VIRTUALENVWRAPPER_VIRTUALENV_CLONE="virtualenv-clone"

fi

# Define script folder depending on the platorm (Win32/Unix)

VIRTUALENVWRAPPER_ENV_BIN_DIR="bin"

if [ "${OS:-}" = "Windows_NT" ] && ([ "${MSYSTEM:-}" = "MINGW32" ] || [ "${MSYSTEM:-}" = "MINGW64" ])

then

# Only assign this for msys, cygwin use standard Unix paths

# and its own python installation

VIRTUALENVWRAPPER_ENV_BIN_DIR="Scripts"

fi

# Let the user override the name of the file that holds the project

# directory name.

if [ "${VIRTUALENVWRAPPER_PROJECT_FILENAME:-}" = "" ]

then

export VIRTUALENVWRAPPER_PROJECT_FILENAME=".project"

fi

# Let the user tell us they never want to cd to projects

# automatically.

export VIRTUALENVWRAPPER_WORKON_CD=${VIRTUALENVWRAPPER_WORKON_CD:-1}

# Remember where we are running from.

if [ -z "${VIRTUALENVWRAPPER_SCRIPT:-}" ]

then

if [ -n "$BASH" ]

then

export VIRTUALENVWRAPPER_SCRIPT="$BASH_SOURCE"

elif [ -n "$ZSH_VERSION" ]

then

export VIRTUALENVWRAPPER_SCRIPT="$0"

else

export VIRTUALENVWRAPPER_SCRIPT="${.sh.file}"

fi

fi

# Portable shell scripting is hard, let's go shopping.

#

# People insist on aliasing commands like 'cd', either with a real

# alias or even a shell function. Under bash and zsh, "builtin" forces

# the use of a command that is part of the shell itself instead of an

# alias, function, or external command, while "command" does something

# similar but allows external commands. We need to use a builtin for

# cd because we are trying to change the state of the current shell,

# so we use "builtin".

function virtualenvwrapper_cd {

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

then

builtin \cd "$@"

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

then

builtin \cd -q "$@"

fi

}

function virtualenvwrapper_expandpath {

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

}

function virtualenvwrapper_absolutepath {

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

return 1

else

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

return 0

fi

}

function virtualenvwrapper_derive_workon_home {

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

}

# Check if the WORKON_HOME directory exists,

# create it if it does not

# seperate from creating the files in it because this used to just error

# and maybe other things rely on the dir existing before that happens.

function virtualenvwrapper_verify_workon_home {

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

}

#HOOK_VERBOSE_OPTION="-q"

# Function to wrap mktemp so tests can replace it for error condition

# testing.

function virtualenvwrapper_mktemp {

command \mktemp "$@"

}

# Expects 1 argument, the suffix for the new file.

function virtualenvwrapper_tempfile {

# 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

}

# Run the hooks

function virtualenvwrapper_run_hook {

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

virtualenvwrapper.sh: There was a problem running the initialization hooks.

If Python could not import the module virtualenvwrapper.hook_loader,

check that virtualenvwrapper has been installed for

VIRTUALENVWRAPPER_PYTHON=$VIRTUALENVWRAPPER_PYTHON and that PATH is

set properly.

EOF

fi

command \rm -f "$hook_script"

return $result

}

# Set up tab completion. (Adapted from Arthur Koziel's version at

# http://arthurkoziel.com/2008/10/11/virtualenvwrapper-bash-completion/)

function virtualenvwrapper_setup_tab_completion {

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

}

# Set up virtualenvwrapper properly

function virtualenvwrapper_initialize {

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

}

# Verify that the passed resource is in path and exists

function virtualenvwrapper_verify_resource {

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

}

# Verify that virtualenv is installed and visible

function virtualenvwrapper_verify_virtualenv {

virtualenvwrapper_verify_resource $VIRTUALENVWRAPPER_VIRTUALENV

}

function virtualenvwrapper_verify_virtualenv_clone {

virtualenvwrapper_verify_resource $VIRTUALENVWRAPPER_VIRTUALENV_CLONE

}

# Verify that the requested environment exists

function virtualenvwrapper_verify_workon_environment {

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

}

# Verify that the active environment exists

function virtualenvwrapper_verify_active_environment {

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

then

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

return 1

fi

return 0

}

# Help text for mkvirtualenv

function virtualenvwrapper_mkvirtualenv_help {

echo "Usage: mkvirtualenv [-a project_path] [-i package] [-r requirements_file] [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 'virtualenv help:';

echo;

"$VIRTUALENVWRAPPER_VIRTUALENV" $@;

}

# Create a new environment, in the WORKON_HOME.

#

# Usage: mkvirtualenv [options] ENVNAME

# (where the options are passed directly to virtualenv)

#

#:help:mkvirtualenv: Create a new virtualenv in $WORKON_HOME

function mkvirtualenv {

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 [ $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"

}

#:help:rmvirtualenv: Remove a virtualenv

function rmvirtualenv {

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

}

# List the available environments.

function virtualenvwrapper_show_workon_options {

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 "/^\s*$/d" \

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

}

function _lsvirtualenv_usage {

echo "lsvirtualenv [-blh]"

echo " -b -- brief mode"

echo " -l -- long mode"

echo " -h -- this help message"

}

#:help:lsvirtualenv: list virtualenvs

function lsvirtualenv {

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

}

#:help:showvirtualenv: show details of a single virtualenv

function showvirtualenv {

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

}

# Show help for workon

function virtualenvwrapper_workon_help {

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 ""

}

#:help:workon: list or change working virtualenvs

function workon {

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 [ $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 () {

typeset env_postdeactivate_hook

typeset old_env

# Call the local hook before the global so we can undo

# any settings made by the local postactivate first.

virtualenvwrapper_run_hook "pre_deactivate"

env_postdeactivate_hook="$VIRTUAL_ENV/$VIRTUALENVWRAPPER_ENV_BIN_DIR/postdeactivate"

old_env=$(basename "$VIRTUAL_ENV")

# Call the original function.

virtualenv_deactivate $1

virtualenvwrapper_run_hook "post_deactivate" "$old_env"

if [ ! "$1" = "nondestructive" ]

then

# Remove this function

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

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

fi

}'

VIRTUALENVWRAPPER_PROJECT_CD=$cd_after_activate virtualenvwrapper_run_hook "post_activate"

return 0

}

# Prints the Python version string for the current interpreter.

function virtualenvwrapper_get_python_version {

# 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.

}

# Prints the path to the site-packages directory for the current environment.

function virtualenvwrapper_get_site_packages_dir {

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

}

# Path management for packages outside of the virtual env.

# Based on a contribution from James Bennett and Jannis Leidel.

#

# add2virtualenv directory1 directory2 ...

#

# Adds the specified directories to the Python path for the

# currently-active virtualenv. This will be done by placing the

# directory names in a path file named

# "virtualenv_path_extensions.pth" inside the virtualenv's

# site-packages directory; if this file does not exist, it will be

# created first.

#

#:help:add2virtualenv: add directory to the import path

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\

'"$absolute_path"'

' "$path_file"

fi

rm -f "${path_file}.tmp"

done

return 0

}

# Does a ``cd`` to the site-packages directory of the currently-active

# virtualenv.

#:help:cdsitepackages: change to the site-packages directory

function cdsitepackages {

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"

}

# Does a ``cd`` to the root of the currently-active virtualenv.

#:help:cdvirtualenv: change to the $VIRTUAL_ENV directory

function cdvirtualenv {

virtualenvwrapper_verify_workon_home || return 1

virtualenvwrapper_verify_active_environment || return 1

virtualenvwrapper_cd "$VIRTUAL_ENV/$1"

}

# Shows the content of the site-packages directory of the currently-active

# virtualenv

#:help:lssitepackages: list contents of the site-packages directory

function lssitepackages {

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

}

#:help:cpvirtualenv: duplicate the named virtualenv to make a new one

function cpvirtualenv {

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

[ ! -d "$WORKON_HOME/$trg_name" ] && return 1