Sourcing paths using $.prefix only works on the first invocation

[ivancuric]

I'm writing a zx script which needs to use a python venv.

I am sourcing the venv using:

  $.prefix += `source .venv/bin/activate`;

No matter if I use it in the root of the document, or in a within scope, it keeps failing after the first call to a binary inside the venv path.

In the end I decided to use:

  process.env.PATH = `${path.join(SOURCE_PATH, ".venv/bin")}:${
    process.env.PATH
  }`;

The activate itself is:

# This file must be used with "source bin/activate" *from bash*
# you cannot run it directly

deactivate () {
    # reset old environment variables
    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
        PATH="${_OLD_VIRTUAL_PATH:-}"
        export PATH
        unset _OLD_VIRTUAL_PATH
    fi
    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
        export PYTHONHOME
        unset _OLD_VIRTUAL_PYTHONHOME
    fi

    # This should detect bash and zsh, which have a hash command that must
    # be called to get it to forget past commands.  Without forgetting
    # past commands the $PATH changes we made may not be respected
    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
        hash -r 2> /dev/null
    fi

    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
        PS1="${_OLD_VIRTUAL_PS1:-}"
        export PS1
        unset _OLD_VIRTUAL_PS1
    fi

    unset VIRTUAL_ENV
    unset VIRTUAL_ENV_PROMPT
    if [ ! "${1:-}" = "nondestructive" ] ; then
    # Self destruct!
        unset -f deactivate
    fi
}

# unset irrelevant variables
deactivate nondestructive

VIRTUAL_ENV="/path/to/.venv"
export VIRTUAL_ENV

_OLD_VIRTUAL_PATH="$PATH"
PATH="$VIRTUAL_ENV/bin:$PATH"
export PATH

# unset PYTHONHOME if set
# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
# could use `if (set -u; : $PYTHONHOME) ;` in bash
if [ -n "${PYTHONHOME:-}" ] ; then
    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
    unset PYTHONHOME
fi

if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
    _OLD_VIRTUAL_PS1="${PS1:-}"
    PS1="(.venv) ${PS1:-}"
    export PS1
    VIRTUAL_ENV_PROMPT="(.venv) "
    export VIRTUAL_ENV_PROMPT
fi

# This should detect bash and zsh, which have a hash command that must
# be called to get it to forget past commands.  Without forgetting
# past commands the $PATH changes we made may not be respected
if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
    hash -r 2> /dev/null
fi

I know that this might be a bit sparse with the info, but I'd really like to understand what's going on under the hood here.

[agammann]

Add a command separator after activate. The prefix is prepended to each shell command; without a separator, source .venv/bin/activate and the following command become one shell command rather than two:

import { $ } from 'zx';

$.prefix += 'source .venv/bin/activate; ';
console.log((await $`python -c "import sys; print(sys.prefix)"`).stdout.trim());
console.log((await $`python -c "import sys; print(sys.prefix)"`).stdout.trim());

With a real Python virtual environment, zx 8.8.4 and Bash, both invocations printed the virtual environment's prefix. Each $ invocation runs in its own shell, so shell state changed by an earlier standalone source command does not persist into the next invocation. Putting activation in the prefix runs it again for each command.

This example assumes the script's working directory contains .venv and uses the POSIX/Bash activation path. Invoking .venv/bin/python directly is another option that avoids activation when you only need that interpreter. Your process-level PATH change also works because subsequent child processes inherit that environment. zx prefix, Python venv activation.