Repository: pyenv/pyenv-virtualenv
Branch: master
Commit: 38f3333f3a24
Files: 49
Total size: 169.7 KB
Directory structure:
gitextract_nqzhc3gf/
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ └── feature_request.md
│ ├── no-response.yml
│ └── workflows/
│ └── tests.yml
├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── LICENSE
├── MAINTENANCE.md
├── README.md
├── bin/
│ ├── pyenv-activate
│ ├── pyenv-deactivate
│ ├── pyenv-sh-activate
│ ├── pyenv-sh-deactivate
│ ├── pyenv-virtualenv
│ ├── pyenv-virtualenv-delete
│ ├── pyenv-virtualenv-init
│ ├── pyenv-virtualenv-prefix
│ └── pyenv-virtualenvs
├── etc/
│ └── pyenv.d/
│ ├── rehash/
│ │ └── envs.bash
│ ├── uninstall/
│ │ └── envs.bash
│ └── which/
│ ├── conda.bash
│ ├── python-config.bash
│ └── system-site-packages.bash
├── install.sh
├── libexec/
│ └── pyenv-virtualenv-realpath
├── shims/
│ ├── activate
│ └── deactivate
└── test/
├── activate.bats
├── conda-activate.bats
├── conda-deactivate.bats
├── conda-prefix.bats
├── conda.bats
├── deactivate.bats
├── delete.bats
├── envs.bats
├── hooks.bats
├── init.bats
├── installer.bats
├── pip.bats
├── prefix.bats
├── python.bats
├── pyvenv.bats
├── stubs/
│ └── stub
├── test_helper.bash
├── version.bats
├── virtualenv.bats
└── virtualenvs.bats
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms
github: [pyenv] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
patreon: # Replace with a single Patreon username
open_collective: pyenv # Replace with a single Open Collective username
ko_fi: # Replace with a single Ko-fi username
tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
otechie: # Replace with a single Otechie username
custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: ''
assignees: ''
---
### Prerequisite
* [ ] Make sure no duplicated issue has already been reported in [the pyenv-virtualenv issues](https://github.com/pyenv/pyenv-virtualenv/issues). You should look in closed issues, too.
* [ ] Make sure you are reporting a problem in Pyenv-Virtualenv and not seeking consultation with Pyenv-Virtualenv use.
* GitHub issues are intended mainly for Pyenv-Virtualenv development purposes. If you are seeking help with Pyenv-Virtualenv use, check [Pyenv-Virtualenv documentation](https://github.com/pyenv/pyenv-virtualenv?tab=readme-ov-file#usage), go to a user community site like [Gitter](https://gitter.im/yyuu/pyenv), [StackOverflow](https://stackoverflow.com/questions/tagged/pyenv), etc, or to [Discussions](https://github.com/orgs/pyenv/discussions).
* [ ] Make sure your problem is not derived from packaging (e.g. [Homebrew](https://brew.sh)).
* Please refer to the package documentation for the installation issues, etc.
* [ ] Make sure your problem is not derived from other plugins.
* This repository is maintaining the `pyenv-virtualenv` plugin only. Please refrain from reporting issues of other plugins here.
### Describe the bug
A clear and concise description of what the bug is.
Do specify what the expected behaviour is if that's not obvious from the bug's nature.
#### Reproduction steps
Listing the commands to run in a new console session and their output is usually sufficient.
Please use a Markdown code block (three backticks on a line by themselves before and after the text) to denote a console output excerpt.
#### Diagnostic details
- [ ] Platform information (e.g. Ubuntu Linux 20.04):
- [ ] OS architecture (e.g. amd64):
- [ ] pyenv version:
- [ ] pyenv-virtualenv version:
- [ ] Python version:
- [ ] virtualenv version (if installed):
- [ ] Please attach the debug log of a faulty Pyenv invocation as a gist
* If the problem happens in a Pyenv invocation, you can turn on debug logging by setting `PYENV_DEBUG=1`, e.g. `env PYENV_DEBUG=1 pyenv install -v 3.6.4`
* If the problem happens outside of a Pyenv invocation, get the debug log like this:
```bash
# for Bash
export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
# for Zsh
export PS4='+(%x:%I): %N(%i): '
set -x
<reproduce the problem>
set +x
```
================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: ''
assignees: ''
---
**Describe the intended use case**
* What your general environment is if it's relevant to the feature request and is not a generic console with a typical Pyenv installation (CI, server with a custom setup, cloud environment, IDE)
* What you are trying to achieve
* What specifically you are doing for that regarding Pyenv
* Where you are stuck
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
[ ] In particular, did you consider [writing a plugin](https://github.com/pyenv/pyenv/blob/master/README.md#pyenv-plugins)? Note that if your plugin has general applicability, you can publish it in the 3rd-party plugin catalog on the Pyenv Wiki as per the link above.
**Additional context**
Add any other context or screenshots about the feature request here.
================================================
FILE: .github/no-response.yml
================================================
# Configuration for probot-no-response - https://github.com/probot/no-response
# Number of days of inactivity before an Issue is closed for lack of response
daysUntilClose: 30
# Label requiring a response
responseRequiredLabel: need-feedback
# Comment to post when closing an Issue for lack of response. Set to `false` to disable
closeComment: >
This issue has been automatically closed because there has been no response
to our request for more information from the original author. With only the
information that is currently in the issue, we don't have enough information
to take action. Please reach out if you have or find the answers we need so
that we can investigate further.
================================================
FILE: .github/workflows/tests.yml
================================================
name: tests
on: [pull_request, push]
jobs:
tests:
strategy:
fail-fast: false
matrix:
os:
- ubuntu-24.04
- ubuntu-22.04
- macos-15-intel
- macos-15
- macos-14
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v2
- run: git clone https://github.com/bats-core/bats-core.git --depth=1 -b v1.10.0 bats
- run: bats/bin/bats --tap test
================================================
FILE: .gitignore
================================================
/bats/
/libexec/pyenv-virtualenv/*/*.class
/libexec/pyenv-virtualenv/*/*.pyc
/libexec/pyenv-virtualenv/*/*.pyo
/libexec/pyenv-virtualenv/*/__pycache__
*.swo
*.swp
================================================
FILE: .travis.yml
================================================
sudo: false
install: git clone --depth=1 https://github.com/sstephenson/bats.git
script: bats/bin/bats --tap test
language: c
notifications:
email:
on_success: never
deploy:
provider: releases
api_key:
secure: DsGAt0UmTSGVfsNJ6LmM+LvsV6FYmvX4FcET82XrskPiQW+N8+8JZR8WuZxfmwdJZu+dkkdoq6gYgL2xF7m4LxRG7aw3B5TtbMTrJQeW0hdtCSBwbbYyvwcp2m7ywE8lGAfZQITaGj1R6f2Cgh8cgtcrErjcF0KJsYlVlgNv+/M=
on:
repo: pyenv/pyenv-virtualenv
tags: true
================================================
FILE: CHANGELOG.md
================================================
## Version History
#### v1.2.6
* Fix changelog and version numbers
#### v1.2.5
* Add prompt customization by @jimenezj8 in https://github.com/pyenv/pyenv-virtualenv/pull/476
* README: fix and distinguish syntax highlighting in Bash vs Fish snippets by @diericx in https://github.com/pyenv/pyenv-virtualenv/pull/489
* Fix pyenv-virtualenv using a different Python version in a conda environment by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/492
* Fix confusing activate/deactivate error messages when Pyenv is not installed as a shell function by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/495
* Fix errorneously creating a symlink inside env directory if running w… by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/496
* Update LICENSE, fix copyright license year by @JasonnnW3000 in https://github.com/pyenv/pyenv-virtualenv/pull/499
* docs: add WSL note about core.autocrlf to prevent CRLF issues by @stoneHee99 in https://github.com/pyenv/pyenv-virtualenv/pull/512
* docs: fix the link to Pyenv shell setup steps by @cshen-dev in https://github.com/pyenv/pyenv-virtualenv/pull/516
* Convert issue template to new Github format by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/519
* Prevent loss of data on `virtualenv-delete -f` if the env doesn't exist and the PREFIX envvar is set elsewhere by @SabriRamadanTNG in https://github.com/pyenv/pyenv-virtualenv/pull/518
#### v1.2.4
* Fix failing to detect `-m venv` when "python" is not provided by the distro by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/479
* README: Remove dollar signs from commands that are meant to be copied by @galonsky in https://github.com/pyenv/pyenv-virtualenv/pull/481
* Reflect pyenv-latest switch change in 2.4.8 by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/484
#### v1.2.3
* Fix: add `colorize` helper by @silverjam in https://github.com/pyenv/pyenv-virtualenv/pull/470
* Bump pyenv-virtualenv reporting version to match release by @ushuz in https://github.com/pyenv/pyenv-virtualenv/pull/471
* Add fish prompt changing by @romirk in https://github.com/pyenv/pyenv-virtualenv/pull/475
* Don't activate if a 3rd-party venv is activated over ours by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/478
#### v1.2.2
* Prompt removal was never done and is not planned anymore by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/447
* Update PYENV_VIRTUALENV_VERSION by @jack-mcivor in https://github.com/pyenv/pyenv-virtualenv/pull/449
* Add activate/deactivate hooks by @joshfrench in https://github.com/pyenv/pyenv-virtualenv/pull/452
* More helpful error message when requesting a nonexistent base version by @MarcinKonowalczyk in https://github.com/pyenv/pyenv-virtualenv/pull/454
* Add fish install oneliner by @ElijahLynn in https://github.com/pyenv/pyenv-virtualenv/pull/322
* Link python*-config into VE by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/460
#### v1.2.1
* Support prefixes resolved by pyenv-latest as base version names by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/446
#### v1.2.0
* ~/.*rc should be modified instead of ~/.*profile by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/384
* Fixes #394 - update pyenv virtualenvs to list virtualenvs start with dot prefixes by @Gauravtalreja1 in https://github.com/pyenv/pyenv-virtualenv/pull/395
* Fix installation steps to allow for Pyenv 2 by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/388
* Fix get-pip.py URLs for older versions of Python by @jivanf in https://github.com/pyenv/pyenv-virtualenv/pull/403
* Add (y/N) prompt help text by @sh-cho in https://github.com/pyenv/pyenv-virtualenv/pull/404
* perf(sh-activate): avoid a pyenv-version-name call by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/380
* Fix unbound variable errors when running `pyenv activate` with `set -u` Use default empty value. This fixes #422. by @ackalker in https://github.com/pyenv/pyenv-virtualenv/pull/423
* Fix another unbound variable error by @ackalker in https://github.com/pyenv/pyenv-virtualenv/pull/424
* Update `get-pip.py` URLs in `pyenv-virtualenv` by @mcdonnnj in https://github.com/pyenv/pyenv-virtualenv/pull/426
* Deduplicate shims in $PATH for the fish shell during initialization by @ericvw in https://github.com/pyenv/pyenv-virtualenv/pull/430
* Upgrade uninstall hook after pyenv/pyenv#2432 by @laggardkernel in https://github.com/pyenv/pyenv-virtualenv/pull/438
* Stop delete force failing when virtualenv does not exist by @eganjs in https://github.com/pyenv/pyenv-virtualenv/pull/330
* fix: relative path to pyenv-realpath.dylib by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/378
* Spelling fixes by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/352
* Clone bats with --depth=1, gitignore it by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/351
* set -u fixes by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/350
* Set up Github Actions CI by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/440
* Enhance documentation about options for `pyenv virtualenv` by @pylipp in https://github.com/pyenv/pyenv-virtualenv/pull/425
* Return control to pyenv-uninstall in uninstall/envs.bash by @aiguofer in https://github.com/pyenv/pyenv-virtualenv/pull/321
* Use realpath of scripts to determine relative locations by @andrew-christianson in https://github.com/pyenv/pyenv-virtualenv/pull/308
* Shell detect improvements by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/377
#### v1.1.5
* Fix install script (#290, #302)
#### v1.1.4
* Support newer conda (#290)
* Prefer `python3.x` executable if available (#206, #282, #296)
#### v1.1.3
* No code changes since 1.1.2
#### v1.1.2
* Use custom get-pip URL based on the target version (#253, #254, #255)
* Source conda 4.4.4 shell files (#251)
* Evaluate force flag before testing if venv exists (#232)
#### v1.1.1
* Set `CONDA_PREFIX` to make is useable in conda activate/deactivate scripts (#224)
* Generate `pydoc` executable after creating new virtualenv (#197, #230)
#### v1.1.0
* fish: use "set -gx" instead of "setenv" (#215, #216, #217, #218)
#### v1.0.0
* Use similar versioning scheme as pyenv; YYYYMMDD -> X.Y.Z
#### v20160716
* Suppress activate/deactivate messages by default (#169, #170, #171)
* Source conda package activate/deactivat scripts if exist (#173)
* Use `source` in favor of `.` for `fish` (#175)
* Use `python -m venv` instead of `pyvenv` due to deprecation of `pyvenv` after 3.6 (#184, #185)
#### v20160315
* Evaluate `${PATH}` when outputted code is eval'd. (#154)
* Set proper `CONDA_DEFAULT_ENV` for shorter name (#160)
#### v20160202
* Install virtualenv 13.1.2 for CPython/Stackless 3.2.x (yyuu/pyenv#531)
#### v20160112
* Fix problem with `virtualenv` to look up executables from source version with `--system-site-packages` (#62)
#### v20151229
* Fix `deactivate` error on `fish` (#136)
#### v20151222
* Improved interoperability with Anaconda/Miniconda (#103, #106, #107, #108)
* Create `virtualenv` inside `envs` directory of source version, like Anaconda/Miniconda (#103, #107)
* Rewrite `pyenv activate` and `pyenv deactivate` without using scripts provided by virtualenv and conda (#51, #69, #103, #104, #121)
* Improve the `pyenv activate` behaviour on multiple versions (#105, #111)
* Reject creating a virtualenv named `system` (yyuu/pyenv#475)
* Add `--skip-aliases` to `pyenv virtualenvs` (#120)
* Stop showing `version not installed` warning messages in precmd (#49)
#### v20151103
* Passing return value from executed command. (#100)
* Add workaround for commands installed in a virtual environment created by `pyvenv` (#62)
* init: zsh: prepend hook to `precmd_functions` (#101)
#### v20151006
* Ignore user's site-packages on ensurepip/get-pip (#89)
* Find `python-config` from source version if current version is a virtualenv
* Fix pyenv-virtualenv-init script for fish where command was in string and not being evaluated (#98)
* Add foolproof for `-p` argument. (yyuu/pyenv#98)
#### v20150719
* Add support for `conda` environments created by Anaconda/Miniconda (#91)
* Look up commands for original version as well if the environment is created with `--system-site-packages` (#62)
* Add error message if the source version is not installed (#83)
#### v20150526
* Use `typeset -g` with `precmd_functions` (#75)
* activate: display setup instructions only with `PYENV_VIRTUALENV_INIT=0` (#78)
* Ignore failure of pyenv activate (#68)
#### v20150119
* Ignore errors from `pyenv-version-name` since it might fail if there is configuration error (yyuu/pyenv#291)
* The _shell_ version set in `activate` should be unset in `deactivate` (#61)
* Anaconda has `activate` script nevertheless it is not a virtual environment (#65)
#### v20141106
* Stop creating after `ensurepip` since it has done by `ensurepip` itself
* Suppress some useless warnings from `pyenv virtualenv-init`
#### v20141012
* Fix warnings from `shellcheck` to improve support for POSIX sh (#40)
* Do not allow whitespace in `VIRTUALENV_NAME` (#44)
* Should not persist `PYENV_DEACTIVATE` after automatic deactivation (#47, #48)
#### v20140705
* Display information on auto-(de)?activation
* Support manual (de)?activation with auto-activation enabled (#32, #34)
* Exit as error when (de)?activation failed
* Use https://bootstrap.pypa.io/ to install setuptools and pip
* Create backup of original virtualenv within `$(pyenv root)/versions` when `--upgrade`
#### v20140615
* Fix incompatibility issue of `pyenv activate` and `pyenv deactivate` (#26)
* Workaround for the issue with pyenv-which-ext (#26)
#### v20140614
* Add `pyenv virtualenv-init` to enable auto-activation feature (#24)
* Create symlinks for executables with version suffix (yyuu/pyenv#182)
#### v20140602
* Use new style GH raw url to avoid redirects (raw.github.com -> raw.githubusercontent.com)
* Repaired virtualenv activation and deactivation for the fish shell (#23)
#### v20140421
* Display error if `pyenv activate` was invoked as a command
* Fix completion of `pyenv activate` (#15)
* Use `virtualenv` instead of `pyvenv` if `-p` has given (yyuu/pyenv#158)
#### v20140123
* Add `activate` and `deactivate` to make `pyenv-virtualenv` work with [jedi](https://github.com/davidhalter/jedi) (#9)
* Use `ensurepip` to install `pip` if it is available
* Unset `PIP_REQUIRE_VENV` to avoid problem on the installation of `virtualenv` (#10)
* Add tests
#### v20140110.1
* Fix install script
#### v20140110
* Support environment variables of `EZ_SETUP` and `GET_PIP`.
* Support a short option `-p` of `virtualenv`.
#### v20131216
* Use latest release of setuptools and pip if the version not given via environment variables.
#### v20130622
* Removed bundled `virtualenv.py` script. Now pyenv-virtualenv installs `virtualenv` package into source version and then use it.
* On Python 3.3+, use `pyvenv` as virtualenv command if `virtualenv` is not available.
* Install setuptools and pip into environments created by `pyvenv`.
#### v20130614
* Add `pyenv virtualenvs` to list all virtualenv versions.
* *EXPERIMENTAL*: Add `--upgrade` option to re-create virtualenv with migrating packages
#### v20130527
* Remove `python-virtualenv` which was no longer used.
* Change the installation path of the `virtualenv.py` script. (`./libexec` -> `./libexec/pyenv-virtualenv/${VIRTUALENV_VERSION}`)
* Download `virtualenv.py` if desired version has not been installed.
#### v20130507
* Display virtualenv information in `--help` and `--version`
* Update virtualenv version; 1.8.4 -> 1.9.1
#### v20130307
* Rename the project; `s/python-virtualenv/pyenv-virtualenv/g`
* The `pyenv-virtualenv` script is not depending on `python-virtualenv` now.
`python-virtualenv` will left for compatibility and will not continue for future releases.
* Update virtualenv version; 1.8.2 -> 1.8.4
#### v20130218
* Add pyenv 0.2.x (rbenv 0.4.x) style help messages.
#### v20121023
* Create virtualenv with exact name of python executables.
* Changed command-line options of python-virtualenv.
First argument should be a path to the python executable.
* Add install script.
#### v20120927
* Initial public release.
================================================
FILE: LICENSE
================================================
Copyright (c) 2025 Yamashita, Yuu
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: MAINTENANCE.md
================================================
Creating a release
==================
The release of the new version of Pyenv is done via GitHub Releases.
Release checklist:
* Start [drafting a new release on GitHub](https://github.com/pyenv/pyenv-virtualenv/releases) to generate a summary of changes. Save the summary locally.
* The summary may need editing. E.g. rephrase entries, delete/merge entries that are too minor or irrelevant to the users (e.g. typo fixes, CI)
* Push the version number in `bin/pyenv-virtualenv`
* Minor version is pushed if there are significant functional changes (not e.g. bugfixes/formula adaptations/supporting niche use cases).
* Major version is pushed if there are breaking changes
* Update `CHANGELOG.md` with the new version number and the edited summary (only the changes section), reformatting it like the rest of the changelog sections
* Commit the changes locally into `master`
* Create a new tag with the new version number and push the changes including the tag
* Create a new release on GitHub based on the tag, using the saved summary
================================================
FILE: README.md
================================================
# pyenv-virtualenv
[](https://gitter.im/yyuu/pyenv-virtualenv?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[](https://travis-ci.org/pyenv/pyenv-virtualenv)
pyenv-virtualenv is a [pyenv](https://github.com/pyenv/pyenv) plugin
that provides features to manage virtualenvs and conda environments
for Python on UNIX-like systems.
(NOTICE: If you are an existing user of [virtualenvwrapper](http://pypi.python.org/pypi/virtualenvwrapper)
and you love it, [pyenv-virtualenvwrapper](https://github.com/pyenv/pyenv-virtualenvwrapper) may help you
(additionally) to manage your virtualenvs.)
## Installation
### Installing as a pyenv plugin
This will install the latest development version of pyenv-virtualenv into
the `$(pyenv root)/plugins/pyenv-virtualenv` directory.
**Important note:** If you installed pyenv into a non-standard directory, make
sure that you clone this repo into the 'plugins' directory of wherever you
installed into.
From inside that directory you can:
- Check out a specific release tag.
- Get the latest development release by running `git pull` to download the
latest changes.
💡 **WSL note:** If you're using WSL, we recommend setting Git to use Unix-style line endings to prevent script execution errors:
```sh
git config --global core.autocrlf input
```
1. **Check out pyenv-virtualenv into plugin directory**
```bash
git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv
```
For the Fish shell:
```fish
git clone https://github.com/pyenv/pyenv-virtualenv.git (pyenv root)/plugins/pyenv-virtualenv
```
2. (OPTIONAL) **Add `pyenv virtualenv-init` to your shell** to enable auto-activation of virtualenvs. This is entirely optional but pretty useful. See "Activate virtualenv" below.
```bash
echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.bashrc
```
**Fish shell note**: Add this to your `~/.config/fish/config.fish`
```fish
status --is-interactive; and pyenv virtualenv-init - | source
```
**Zsh note**: Modify your `~/.zshrc` file instead of `~/.bashrc`.
3. **Restart your shell to enable pyenv-virtualenv**
```bash
exec "$SHELL"
```
### Installing with Homebrew (for macOS users)
macOS users can install pyenv-virtualenv with the
[Homebrew](https://brew.sh) package manager.
This will give you access to the `pyenv-virtualenv` command. If you have pyenv
installed, you will also be able to use the `pyenv virtualenv` command.
*This is the recommended method of installation if you installed pyenv
with Homebrew.*
```sh
brew install pyenv-virtualenv
```
Or, if you would like to install the latest development release:
```sh
brew install --HEAD pyenv-virtualenv
```
After installation, you'll still need to do
[Pyenv shell setup steps](https://github.com/pyenv/pyenv#b-set-up-your-shell-environment-for-pyenv)
then add
```sh
eval "$(pyenv virtualenv-init -)"
```
to your shell's `.rc` file (as stated in the caveats). You'll only ever have to do this once.
## Usage
### Using `pyenv virtualenv` with pyenv
To create a virtualenv for the Python version used with pyenv, run
`pyenv virtualenv`, specifying the Python version you want and the name
of the virtualenv directory. For example,
```sh
pyenv virtualenv 2.7.10 my-virtual-env-2.7.10
```
will create a virtualenv based on Python 2.7.10 under `$(pyenv root)/versions` in a
folder called `my-virtual-env-2.7.10`.
`pyenv virtualenv` forwards any options to the underlying command that actually
creates the virtual environment (`conda`, `virtualenv`, or `python -m venv`).
See the output of `pyenv virtualenv --help` for details.
### Create virtualenv from current version
If there is only one argument given to `pyenv virtualenv`, the virtualenv will
be created with the given name based on the current pyenv Python version.
```sh
$ pyenv version
3.4.3 (set by /home/yyuu/.pyenv/version)
$ pyenv virtualenv venv34
```
### List existing virtualenvs
`pyenv virtualenvs` shows you the list of existing virtualenvs and `conda` environments.
```sh
$ pyenv shell venv34
$ pyenv virtualenvs
miniconda3-3.9.1 (created from /home/yyuu/.pyenv/versions/miniconda3-3.9.1)
miniconda3-3.9.1/envs/myenv (created from /home/yyuu/.pyenv/versions/miniconda3-3.9.1)
2.7.10/envs/my-virtual-env-2.7.10 (created from /home/yyuu/.pyenv/versions/2.7.10)
3.4.3/envs/venv34 (created from /home/yyuu/.pyenv/versions/3.4.3)
my-virtual-env-2.7.10 (created from /home/yyuu/.pyenv/versions/2.7.10)
* venv34 (created from /home/yyuu/.pyenv/versions/3.4.3)
```
There are two entries for each virtualenv, and the shorter one is just a symlink.
### Activate virtualenv
Some external tools (e.g. [jedi](https://github.com/davidhalter/jedi)) might
require you to `activate` the virtualenv and `conda` environments.
If `eval "$(pyenv virtualenv-init -)"` is configured in your shell, `pyenv-virtualenv` will automatically activate/deactivate virtualenvs on entering/leaving directories which contain a `.python-version` file that contains the name of a valid virtual environment as shown in the output of `pyenv virtualenvs` (e.g., `venv34` or `3.4.3/envs/venv34` in example above) . `.python-version` files are used by pyenv to denote local Python versions and can be created and deleted with the [`pyenv local`](https://github.com/pyenv/pyenv/blob/master/COMMANDS.md#pyenv-local) command.
You can also activate and deactivate a pyenv virtualenv manually:
```sh
pyenv activate <name>
pyenv deactivate
```
### Delete existing virtualenv
Removing the directories in `$(pyenv root)/versions` and `$(pyenv root)/versions/{version}/envs` will delete the virtualenv, or you can run:
```sh
pyenv uninstall my-virtual-env
```
You can also delete existing virtualenvs by using `virtualenv-delete` command, e.g. you can run:
```sh
pyenv virtualenv-delete my-virtual-env
```
This will delete virtualenv called `my-virtual-env`.
### virtualenv and venv
There is a [venv](http://docs.python.org/3/library/venv.html) module available
for CPython 3.3 and newer.
It provides an executable module `venv` which is the successor of `virtualenv`
and distributed by default.
`pyenv-virtualenv` uses `python -m venv` if it is available and the `virtualenv`
command is not available.
### Anaconda and Miniconda
You can manage `conda` environments by `conda create` as same manner as standard Anaconda/Miniconda installations.
To use those environments, you can use `pyenv activate` and `pyenv deactivate`.
```sh
$ pyenv version
miniconda3-3.9.1 (set by /home/yyuu/.pyenv/version)
$ conda env list
# conda environments:
#
myenv /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv
root * /home/yyuu/.pyenv/versions/miniconda3-3.9.1
$ pyenv activate miniconda3-3.9.1/envs/myenv
discarding /home/yyuu/.pyenv/versions/miniconda3-3.9.1/bin from PATH
prepending /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv/bin to PATH
$ python --version
Python 3.4.3 :: Continuum Analytics, Inc.
$ pyenv deactivate
discarding /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv/bin from PATH
```
If `conda` is available, `pyenv virtualenv` will use it to create environment by `conda create`.
```sh
$ pyenv version
miniconda3-3.9.1 (set by /home/yyuu/.pyenv/version)
$ pyenv virtualenv myenv2
$ conda env list
# conda environments:
#
myenv /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv
myenv /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv2
root * /home/yyuu/.pyenv/versions/miniconda3-3.9.1
```
You can use version like `miniconda3-3.9.1/envs/myenv` to specify `conda` environment as a version in pyenv.
```sh
$ pyenv version
miniconda3-3.9.1 (set by /home/yyuu/.pyenv/version)
$ pyenv shell miniconda3-3.9.1/envs/myenv
$ which python
/home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv/bin/python
```
### Special environment variables
You can set certain environment variables to control pyenv-virtualenv.
* `PYENV_VIRTUALENV_CACHE_PATH`, if set, specifies a directory to use for
caching downloaded package files.
* `VIRTUALENV_VERSION`, if set, forces pyenv-virtualenv to install the desired
version of virtualenv. If `virtualenv` has not been installed,
pyenv-virtualenv will try to install the given version of virtualenv.
* `GET_PIP`, if set and `venv` is preferred over `virtualenv`,
use `get_pip.py` from the specified location.
* `GET_PIP_URL`, if set and `venv` is preferred over
`virtualenv`, download `get_pip.py` from the specified URL.
* `PIP_VERSION`, if set and `venv` is preferred
over `virtualenv`, install the specified version of pip.
* `PYENV_VIRTUALENV_VERBOSE_ACTIVATE`, if set, shows some verbose outputs on activation and deactivation
* `PYENV_VIRTUALENV_PROMPT`, if set, allows users to customize how `pyenv-virtualenv` modifies their shell prompt. The default prompt ("(venv)") is overwritten with any user-specified text. Specify the location of the virtual environment name with the string `{venv}`. For example, the default prompt string would be `({venv})`.
## Version History
See [CHANGELOG.md](CHANGELOG.md).
### License
[(The MIT License)](LICENSE)
* Copyright (c) 2015 Yamashita, Yuu
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: bin/pyenv-activate
================================================
#!/usr/bin/env bash
#
# Summary: Activate virtual environment
#
# Usage: pyenv activate <virtualenv>
# pyenv activate --unset
#
# Activate a Python virtualenv environment in current shell.
# This acts almost as same as `pyenv shell`, but this invokes the `activate`
# script in your shell.
#
# <virtualenv> should be a string matching a Python version known to pyenv.
set -e
[ -n "$PYENV_DEBUG" ] && set -x
# Provide pyenv completions
if [ "$1" = "--complete" ]; then
echo --unset
exec pyenv-virtualenvs --bare
fi
{ printf "\x1B[31;1m"
echo
echo "\`pyenv activate' requires Pyenv and Pyenv-Virtualenv to be loaded into your shell."
echo "Check your shell configuration and Pyenv and Pyenv-Virtualenv installation instructions."
echo
printf "\x1B[0m"
} 1>&2
exit 1
================================================
FILE: bin/pyenv-deactivate
================================================
#!/usr/bin/env bash
#
# Summary: Deactivate virtual environment
#
# Usage: pyenv deactivate
#
# Deactivate a Python virtual environment.
set -e
[ -n "$PYENV_DEBUG" ] && set -x
{ printf "\x1B[31;1m"
echo
echo "\`pyenv deactivate' requires Pyenv and Pyenv-Virtualenv to be loaded into your shell."
echo "Check your shell configuration and Pyenv and Pyenv-Virtualenv installation instructions."
echo
printf "\x1B[0m"
} 1>&2
exit 1
================================================
FILE: bin/pyenv-sh-activate
================================================
#!/usr/bin/env bash
#
# Summary: Activate virtual environment
#
# Usage: pyenv activate <virtualenv>
# pyenv activate --unset
#
# Activate a Python virtualenv environment in current shell.
# This acts almost as same as `pyenv shell`, but this invokes the `activate`
# script in your shell.
#
# <virtualenv> should be a string matching a Python version known to pyenv.
set -e
[ -n "$PYENV_DEBUG" ] && set -x
if [ -z "${PYENV_ROOT}" ]; then
PYENV_ROOT="$(pyenv-root)"
fi
resolve_link() {
$(type -p greadlink readlink | head -1) "$1"
}
unset FORCE
unset QUIET
# Define `before_activate` and `after_activate` functions that allow
# plugin hooks to register a string of code for execution before or
# after activating a virtualenv.
declare -a before_hooks after_hooks
before_activate() {
local hook="$1"
before_hooks["${#before_hooks[@]}"]="$hook"
}
after_activate() {
local hook="$1"
after_hooks["${#after_hooks[@]}"]="$hook"
}
# Load plugin hooks.
OLDIFS="$IFS"
IFS=$'\n' scripts=(`pyenv-hooks activate`)
IFS="$OLDIFS"
for script in "${scripts[@]}"; do source "$script"; done
while [ $# -gt 0 ]; do
case "$1" in
"--complete" )
# Provide pyenv completions
echo --unset
exec pyenv-virtualenvs --bare
;;
"-f" | "--force" )
FORCE=1
;;
"-q" | "--quiet" )
QUIET=1
;;
"--unset" )
exec pyenv-sh-deactivate
;;
"-v" | "--verbose" )
unset QUIET
PYENV_VIRTUALENV_VERBOSE_ACTIVATE=1
;;
* )
break
;;
esac
shift 1
done
get_current_versions() {
local IFS=:
current_versions=($(pyenv-version-name 2>/dev/null))
}
no_shell=
versions=("$@")
current_versions=()
if [ -z "${versions}" ]; then
no_shell=1
get_current_versions
versions=("${current_versions[@]}")
fi
if [ -z "${PYENV_VIRTUALENV_INIT}" ]; then
# Backward compatibility issue
# https://github.com/yyuu/pyenv-virtualenv/issues/26
no_shell=
fi
venv="${versions}"
if [ -n "${VIRTUAL_ENV}" ]; then
# exit as success if a non-pyenv virtualenv is active
if [[ -z $PYENV_VIRTUAL_ENV || $PYENV_VIRTUAL_ENV != "$VIRTUAL_ENV" ]]; then
if [ -z "${FORCE}" ]; then
if [ -z "${QUIET}" ]; then
echo "pyenv-virtualenv: virtualenv \`${VIRTUAL_ENV}' is already activated" 1>&2
fi
echo "true"
exit 0
fi
fi
fi
if ! pyenv-virtualenv-prefix "${venv}" 1>/dev/null 2>&1; then
# fallback to virtualenv of current version
[ -n "${current_versions}" ] || get_current_versions
new_venv="${current_versions%/envs/*}/envs/${venv}"
if pyenv-virtualenv-prefix "${new_venv}" 1>/dev/null 2>&1; then
venv="${new_venv}"
versions[0]="${new_venv}"
else
if [ -z "${QUIET}" ]; then
echo "pyenv-virtualenv: version \`${venv}' is not a virtualenv" 1>&2
fi
echo "false"
exit 1
fi
fi
# exit as error if there are multiple virtualenvs
# https://github.com/yyuu/pyenv-virtualenv/issues/105
for version in "${versions[@]}"; do
if [[ "${version}" != "${venv}" ]]; then
if pyenv-virtualenv-prefix "${version}" 1>/dev/null 2>&1; then
if [ -z "${QUIET}" ]; then
echo "pyenv-virtualenv: cannot activate multiple versions at once: ${versions[@]}" 1>&2
fi
echo "false"
exit 1
fi
fi
done
shell="${PYENV_SHELL:-${SHELL##*/}}"
prefix="$(pyenv-prefix "${venv}")"
if [ -L "${prefix}" ]; then
prefix="$(resolve_link "${prefix}" 2>/dev/null)"
fi
# exit as success if the virtualenv is already activated
if [[ "${VIRTUAL_ENV}" == "${prefix}" ]]; then
if [ -z "${FORCE}" ]; then
if [ -z "${QUIET}" ]; then
echo "pyenv-virtualenv: version \`${venv}' is already activated" 1>&2
fi
echo "true"
exit 0
fi
fi
pyenv-sh-deactivate --force --quiet || true
# Execute `before_activate` hooks.
for hook in "${before_hooks[@]}"; do eval "$hook"; done
if [ -n "$PYENV_VIRTUALENV_VERBOSE_ACTIVATE" ]; then
echo "pyenv-virtualenv: activate ${venv}" 1>&2
fi
if [ -z "$no_shell" ]; then
# shell version set in pyenv-sh-activate should be unset
# https://github.com/yyuu/pyenv-virtualenv/issues/61
OLDIFS="$IFS"
IFS=:
case "$shell" in
fish )
cat <<EOS
set -gx PYENV_VERSION "${versions[*]}";
set -gx PYENV_ACTIVATE_SHELL 1;
EOS
;;
* )
cat <<EOS
export PYENV_VERSION="${versions[*]}";
export PYENV_ACTIVATE_SHELL=1;
EOS
;;
esac
IFS="$OLDIFS"
fi
# virtualenv/venv
case "${shell}" in
fish )
cat <<EOS
set -gx PYENV_VIRTUAL_ENV "${prefix}";
set -gx VIRTUAL_ENV "${prefix}";
EOS
;;
* )
cat <<EOS
export PYENV_VIRTUAL_ENV="${prefix}";
export VIRTUAL_ENV="${prefix}";
EOS
;;
esac
# anaconda/miniconda
if [ -d "${prefix}/conda-meta" ] ||
[ -x "${prefix}/bin/conda" ]; then
if [[ "${prefix}" != "${prefix%/envs/*}" ]]; then
CONDA_DEFAULT_ENV="${venv##*/envs/}"
else
CONDA_DEFAULT_ENV="root"
fi
case "${shell}" in
fish )
echo "set -gx CONDA_DEFAULT_ENV \"${CONDA_DEFAULT_ENV}\";"
;;
* )
echo "export CONDA_DEFAULT_ENV=\"${CONDA_DEFAULT_ENV}\";"
;;
esac
fi
if [ -n "${PYTHONHOME}" ]; then
case "${shell}" in
fish )
cat <<EOS
set -gx _OLD_VIRTUAL_PYTHONHOME "${PYTHONHOME}";
set -e PYTHONHOME;
EOS
;;
* )
cat <<EOS
export _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME}";
unset PYTHONHOME;
EOS
;;
esac
fi
PYENV_VIRTUALENV_DISABLE_PROMPT="${PYENV_VIRTUALENV_DISABLE_PROMPT:-${PYENV_VIRTUAL_ENV_DISABLE_PROMPT}}"
PYENV_VIRTUALENV_DISABLE_PROMPT="${PYENV_VIRTUALENV_DISABLE_PROMPT:-${VIRTUAL_ENV_DISABLE_PROMPT}}"
if [ -z "${PYENV_VIRTUALENV_DISABLE_PROMPT}" ]; then
case "${shell}" in
fish )
if [ -z "${QUIET}" ]; then
cat <<EOS
functions -e _pyenv_old_prompt # remove old prompt function if exists.
# since everything is in memory, it's safe to
# remove it.
functions -c fish_prompt _pyenv_old_prompt # backup old prompt function
# from python-venv
function fish_prompt
set -l prompt (_pyenv_old_prompt) # call old prompt function first since it might
# read exit status
echo -n "(${venv}) " # add virtualenv to prompt
string join -- \n \$prompt # handle multiline prompts
end
EOS
fi
;;
* )
if [ -z "${PYENV_VIRTUALENV_PROMPT}" ]; then
PYENV_VIRTUALENV_PROMPT="(${venv})"
else
PYENV_VIRTUALENV_PROMPT="${PYENV_VIRTUALENV_PROMPT/\{venv\}/${venv}}"
fi
cat <<EOS
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="${PYENV_VIRTUALENV_PROMPT} \${PS1:-}";
EOS
;;
esac
fi
# conda package anaconda/miniconda scripts (#173)
if [ -d "${prefix}/conda-meta" ] ||
[ -x "${prefix}/bin/conda" ]; then
shopt -s nullglob
case "${shell}" in
fish )
# conda 4.4 and above
for script in "${prefix}/etc/fish/conf.d"/*.fish; do
echo "source \"${script}\";"
done
;;
* )
CONDA_PREFIX="$prefix"
echo "export CONDA_PREFIX=\"${CONDA_PREFIX}\";"
for script in "${prefix}/etc/conda/activate.d"/*.sh; do
echo ". \"${script}\";"
done
# conda 4.4 and above
for script in "${prefix}/etc/profile.d"/*.sh; do
echo ". \"${script}\";"
done
;;
esac
shopt -u nullglob
fi
# Execute `after_activate` hooks.
for hook in "${after_hooks[@]}"; do eval "$hook"; done
================================================
FILE: bin/pyenv-sh-deactivate
================================================
#!/usr/bin/env bash
#
# Summary: Deactivate virtual environment
#
# Usage: pyenv deactivate
#
# Deactivate a Python virtual environment.
set -e
[ -n "$PYENV_DEBUG" ] && set -x
if [ -z "${PYENV_ROOT}" ]; then
PYENV_ROOT="$(pyenv-root)"
fi
unset FORCE
unset QUIET
# Define `before_deactivate` and `after_deactivate` functions that allow
# plugin hooks to register a string of code for execution before or
# after deactivating a virtualenv.
declare -a before_hooks after_hooks
before_deactivate() {
local hook="$1"
before_hooks["${#before_hooks[@]}"]="$hook"
}
after_deactivate() {
local hook="$1"
after_hooks["${#after_hooks[@]}"]="$hook"
}
# Load plugin hooks.
OLDIFS="$IFS"
IFS=$'\n' scripts=(`pyenv-hooks deactivate`)
IFS="$OLDIFS"
for script in "${scripts[@]}"; do source "$script"; done
while [ $# -gt 0 ]; do
case "$1" in
"-f" | "--force" )
FORCE=1
;;
"-q" | "--quiet")
QUIET=1
;;
"-v" | "--verbose" )
unset QUIET
PYENV_VIRTUALENV_VERBOSE_ACTIVATE=1
;;
* )
break
;;
esac
shift 1
done
if [ -z "${VIRTUAL_ENV}" ]; then
if [ -z "${FORCE}" ]; then
if [ -z "${QUIET}" ]; then
echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2
fi
echo "false"
exit 1
fi
fi
shell="$(basename "${PYENV_SHELL:-$SHELL}")"
prefix="${VIRTUAL_ENV}"
if [[ "${prefix%/*/envs/*}" == "${PYENV_ROOT}/versions" ]]; then
venv="${prefix#${PYENV_ROOT}/versions/}"
else
venv="${prefix##*/}"
fi
# Execute `before_deactivate` hooks.
for hook in "${before_hooks[@]}"; do eval "$hook"; done
if [ -n "$PYENV_VIRTUALENV_VERBOSE_ACTIVATE" ]; then
echo "pyenv-virtualenv: deactivate ${venv}" 1>&2
fi
# conda package anaconda/miniconda scripts (#173)
if [ -d "${prefix}/conda-meta" ] ||
[ -x "${prefix}/bin/conda" ]; then
shopt -s nullglob
case "${shell}" in
fish )
: # conda doesn't support fish
;;
* )
for script in "${prefix}/etc/conda/deactivate.d"/*.sh; do
echo ". \"${script}\";"
done
echo "unset CONDA_PREFIX"
;;
esac
shopt -u nullglob
fi
if [ -n "${PYENV_ACTIVATE_SHELL}" ]; then
# shell version set in pyenv-sh-activate should be unset
# https://github.com/yyuu/pyenv-virtualenv/issues/61
case "$shell" in
fish )
cat <<EOS
set -e PYENV_VERSION;
set -e PYENV_ACTIVATE_SHELL;
EOS
;;
* )
cat <<EOS
unset PYENV_VERSION;
unset PYENV_ACTIVATE_SHELL;
EOS
;;
esac
fi
# virtualenv/venv
case "${shell}" in
fish )
cat <<EOS
set -e PYENV_VIRTUAL_ENV;
set -e VIRTUAL_ENV;
EOS
;;
* )
cat <<EOS
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
EOS
;;
esac
# anaconda/miniconda
if [ -n "${CONDA_DEFAULT_ENV}" ]; then
case "${shell}" in
fish )
echo "set -e CONDA_DEFAULT_ENV;"
;;
* )
echo "unset CONDA_DEFAULT_ENV;"
;;
esac
fi
case "${shell}" in
fish )
cat <<EOS
if [ -n "\$_OLD_VIRTUAL_PATH" ];
set -gx PATH "\$_OLD_VIRTUAL_PATH";
set -e _OLD_VIRTUAL_PATH;
end;
EOS
;;
* )
cat <<EOS
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
EOS
;;
esac
case "${shell}" in
fish )
cat <<EOS
if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
set -e _OLD_VIRTUAL_PYTHONHOME;
end;
EOS
;;
* )
cat <<EOS
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
EOS
;;
esac
case "${shell}" in
fish )
cat <<EOS
# check if old prompt function exists
if functions -q _pyenv_old_prompt
# remove old prompt function if exists.
functions -e fish_prompt
functions -c _pyenv_old_prompt fish_prompt
functions -e _pyenv_old_prompt
end
EOS
;;
* )
cat <<EOS
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
EOS
;;
esac
case "${shell}" in
fish )
cat <<EOS
if functions -q deactivate;
functions -e deactivate;
end;
EOS
;;
* )
cat <<EOS
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
EOS
;;
esac
# Execute `after_deactivate` hooks.
for hook in "${after_hooks[@]}"; do eval "$hook"; done
================================================
FILE: bin/pyenv-virtualenv
================================================
#!/usr/bin/env bash
#
# Summary: Create a Python virtualenv using the pyenv-virtualenv plugin
#
# Usage: pyenv virtualenv [-f|--force] [VIRTUALENV_OPTIONS] [version] <virtualenv-name>
# pyenv virtualenv --version
# pyenv virtualenv --help
#
# -f/--force Install even if the version appears to be installed already. Skip
# prompting for confirmation
#
# Notable VIRTUALENV_OPTIONS passed to venv-creating executable, if applicable:
# -u/--upgrade Imply --force
#
PYENV_VIRTUALENV_VERSION="1.2.6"
set -e
[ -n "$PYENV_DEBUG" ] && set -x
if [ -z "${PYENV_ROOT}" ]; then
PYENV_ROOT="$(pyenv-root)"
fi
# Provide pyenv completions
if [ "$1" = "--complete" ]; then
exec pyenv-versions --bare
fi
unset PIP_REQUIRE_VENV
unset PIP_REQUIRE_VIRTUALENV
# Define library functions
parse_options() {
OPTIONS=()
ARGUMENTS=()
local arg option index
for arg in "$@"; do
if [ "${arg:0:1}" = "-" ]; then
if [ "${arg:1:1}" = "-" ]; then
OPTIONS[${#OPTIONS[*]}]="${arg:2}"
else
index=1
while option="${arg:$index:1}"; do
[ -n "$option" ] || break
OPTIONS[${#OPTIONS[*]}]="$option"
index=$(($index+1))
done
fi
else
ARGUMENTS[${#ARGUMENTS[*]}]="$arg"
fi
done
}
colorize() {
if [ -t 1 ]; then printf "\e[%sm%s\e[m" "$1" "$2"
else echo -n "$2"
fi
}
resolve_link() {
$(type -p greadlink readlink | head -1) "$1"
}
abs_dirname() {
local cwd="$(pwd)"
local path="$1"
while [ -n "$path" ]; do
cd "${path%/*}"
local name="${path##*/}"
path="$(resolve_link "$name" || true)"
done
pwd
cd "$cwd"
}
http() {
local method="$1"
local url="$2"
local file="$3"
[ -n "$url" ] || return 1
if type curl &>/dev/null; then
"http_${method}_curl" "$url" "$file"
elif type wget &>/dev/null; then
"http_${method}_wget" "$url" "$file"
else
echo "error: please install \`curl\` or \`wget\` and try again" >&2
exit 1
fi
}
http_head_curl() {
curl -qsILf "$1" >&4 2>&1
}
http_get_curl() {
curl -C - -o "${2:--}" -qsSLf "$1"
}
http_head_wget() {
wget -q --spider "$1" >&4 2>&1
}
http_get_wget() {
wget -nv -c -O "${2:--}" "$1"
}
version() {
if [[ -z "${PYENV_VERSION:-}" ]]; then
# `PYENV_VERSION` might not be declared if this was invoked via `--version`
export PYENV_VERSION="$(pyenv-version-name)"
fi
detect_venv
local version
if [ -n "${USE_CONDA}" ]; then
version="$(pyenv-exec conda --version 2>/dev/null || true)"
echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (conda ${version:-unknown})"
else
if [ -n "$USE_M_VENV" ]; then
echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (${M_VENV_PYTHON_BIN:-python} -m venv)"
else
version="$(pyenv-exec virtualenv --version 2>/dev/null || true)"
echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (virtualenv ${version:-unknown})"
fi
fi
}
usage() {
# We can remove the sed fallback once pyenv 0.2.0 is widely available.
pyenv-help virtualenv 2>/dev/null || sed -ne '/^#/!q;s/.//;s/.//;1,4d;p' < "$0"
if [ -n "${USE_CONDA}" ]; then
pyenv-exec conda create --help 2>/dev/null || true
else
if [ -n "${USE_M_VENV}" ]; then
pyenv-exec "${M_VENV_PYTHON_BIN:-python}" -m venv --help 2>/dev/null || true
else
pyenv-exec virtualenv --help 2>/dev/null || true
fi
fi
[ -z "$1" ] || exit "$1"
}
detect_venv() {
# Check the existence of executables as a workaround for the issue with pyenv-which-ext
# https://github.com/yyuu/pyenv-virtualenv/issues/26
local prefix="$(pyenv-prefix)"
if [ -x "${prefix}/bin/conda" ]; then
HAS_CONDA=1
else
if [ -x "${prefix}/bin/virtualenv" ]; then
HAS_VIRTUALENV=1
fi
local python
local -a pythons
if [[ $PYENV_VERSION == "system" ]]; then
# Prefer `python3.x` executable if available (#206, #282)
pythons=("python3" "python" "python2")
else
# as per PEP 394, custom activated Python environments should provide the "python" command
# this includes Pyenv-provided installations
pythons=("python")
fi
for python in "${pythons[@]}"; do
if pyenv-exec "${python}" -m venv --help 1>/dev/null 2>&1; then
HAS_M_VENV=1
M_VENV_PYTHON_BIN="${python}"
break
fi
done
fi
# Use `python -m venv` only if there is venv available, virtualenv is not installed, and `-p` not given
if [ -n "${HAS_CONDA}" ]; then
USE_CONDA=1
else
if [ -n "${HAS_M_VENV}" ] && [ -z "${HAS_VIRTUALENV}" ] && [ -z "${VIRTUALENV_PYTHON}" ]; then
USE_M_VENV=1
fi
fi
}
build_package_ez_setup() {
local ez_setup="${PYENV_VIRTUALENV_CACHE_PATH}/ez_setup.py"
rm -f "${ez_setup}"
{ if [ "${EZ_SETUP+defined}" ] && [ -f "${EZ_SETUP}" ]; then
echo "Installing setuptools from ${EZ_SETUP}..." 1>&2
cat "${EZ_SETUP}"
else
[ -n "${EZ_SETUP_URL}" ]
echo "Installing setuptools from ${EZ_SETUP_URL}..." 1>&2
http get "${EZ_SETUP_URL}"
fi
} 1> "${ez_setup}"
pyenv-exec python -s "${ez_setup}" ${EZ_SETUP_OPTS} 1>&2 || {
echo "error: failed to install setuptools via ez_setup.py" >&2
return 1
}
}
build_package_get_pip() {
local get_pip="${PYENV_VIRTUALENV_CACHE_PATH}/get-pip.py"
rm -f "${get_pip}"
{ if [ "${GET_PIP+defined}" ] && [ -f "${GET_PIP}" ]; then
echo "Installing pip from ${GET_PIP}..." 1>&2
cat "${GET_PIP}"
else
[ -n "${GET_PIP_URL}" ]
echo "Installing pip from ${GET_PIP_URL}..." 1>&2
http get "${GET_PIP_URL}"
fi
} 1> "${get_pip}"
pyenv-exec python -s "${get_pip}" ${GET_PIP_OPTS} 1>&2 || {
echo "error: failed to install pip via get-pip.py" >&2
return 1
}
}
build_package_ensurepip() {
pyenv-exec python -s -m ensurepip 2>/dev/null || build_package_get_pip "$@" || return 1
}
prepare_requirements() {
pyenv-exec pip freeze > "${REQUIREMENTS}"
mv -f "${VIRTUALENV_PATH}" "${VIRTUALENV_ORIG}"
}
install_requirements() {
if [ -f "${REQUIREMENTS}" ]; then
## Migrate previously installed packages from requirements.txt
pyenv-exec pip install $QUIET $VERBOSE --requirement "${REQUIREMENTS}" || {
echo
echo "PIP INSTALL FAILED"
echo
echo "Inspect or clean up the original tree at ${VIRTUALENV_ORIG}"
echo
echo "Package list:"
cat "${REQUIREMENTS}" | sed 's/^/ * /'
return 1
} 1>&2
rm -f "${REQUIREMENTS}"
rm -fr "${VIRTUALENV_ORIG}"
fi
}
PYENV_VIRTUALENV_ROOT="$(abs_dirname "$0")/.."
if [ -z "${PYENV_VIRTUALENV_CACHE_PATH}" ]; then
PYENV_VIRTUALENV_CACHE_PATH="${PYTHON_BUILD_CACHE_PATH:-${PYENV_ROOT}/cache}"
fi
VIRTUALENV_OPTIONS=()
unset FORCE
unset NO_ENSUREPIP
unset QUIET
unset UPGRADE
unset VERBOSE
unset VIRTUALENV_PYTHON
parse_options "$@"
for option in "${OPTIONS[@]}"; do
case "$option" in
"f" | "force" )
FORCE=true
;;
"h" | "help" )
usage 0
;;
"no-pip" )
NO_ENSUREPIP=1
VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
;;
"no-setuptools" )
NO_ENSUREPIP=1
VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
;;
"p" | "python" )
VIRTUALENV_PYTHON="${ARGUMENTS[0]}"
ARGUMENTS=("${ARGUMENTS[@]:1}") # shift 1
;;
"q" | "quiet" )
QUIET="--quiet"
;;
"u" | "upgrade" )
UPGRADE=true
;;
"v" | "verbose" )
VERBOSE="--verbose"
;;
"version" )
version
exit 0
;;
"without-pip" )
NO_ENSUREPIP=1
VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
;;
* ) # virtualenv long options
if [[ "$option" == "python="* ]]; then
VIRTUALENV_PYTHON="${option#python=}"
else
VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
fi
;;
esac
done
if [[ "${#ARGUMENTS[@]}" == 0 ]]; then
echo "pyenv-virtualenv: no virtualenv name given." 1>&2
exit 1
elif [[ "${#ARGUMENTS[@]}" == 1 ]]; then
# If only one argument given, use current version as source version
OLDIFS="${IFS}"
IFS=:
VERSION_NAMES=($(pyenv-version-name))
IFS="${OLDIFS}"
VERSION_NAME="${VERSION_NAMES}"
VIRTUALENV_NAME="${ARGUMENTS[0]}"
else
# Otherwise, use former as source version, and latter as virtualenv version
VERSION_NAME="${ARGUMENTS[0]}"
VIRTUALENV_NAME="${ARGUMENTS[1]}"
fi
if [[ -n "${VERSION_NAME}" ]] && command -v pyenv-latest >/dev/null; then
VERSION_NAME="$(pyenv-latest -f "${VERSION_NAME}")"
fi
if [ -z "${VERSION_NAME}" ] || [ -z "${VIRTUALENV_NAME}" ]; then
usage 1
fi
if [[ "${VIRTUALENV_NAME##*/}" == "system" ]]; then
echo "pyenv-virtualenv: \`system' is not allowed as virtualenv name." 1>&2
exit 1
fi
if [ "$VIRTUALENV_NAME" != "${VIRTUALENV_NAME%[[:space:]]*}" ]; then
echo "pyenv-virtualenv: no whitespace allowed in virtualenv name." 1>&2
exit 1
fi
if [ "${VIRTUALENV_NAME}" != "${VIRTUALENV_NAME%/*}" ] && [[ "${VIRTUALENV_NAME}" != "${VERSION_NAME%%/*}/envs/${VIRTUALENV_NAME##*/}" ]] ; then
echo "pyenv-virtualenv: no slash allowed in virtualenv name." 1>&2
exit 1
fi
# Set VERSION_NAME as default version in this script
export PYENV_VERSION="${VERSION_NAME}"
not_installed_message() {
local is_available=$(python-build --definitions | grep -F -x "$1")
echo "pyenv-virtualenv: \`${1}' is not installed in pyenv." 1>&2
if [[ $is_available ]]; then
echo "Run \`pyenv install ${1}' to install it." 1>&2
else
echo "It does not look like a valid Python version. See \`pyenv install --list' for available versions." 1>&2
fi
}
# Source version must exist before creating virtualenv.
PREFIX="$(pyenv-prefix 2>/dev/null || true)"
if [ ! -d "${PREFIX}" ]; then
not_installed_message "${PYENV_VERSION}"
exit 1
fi
if [ -z "$TMPDIR" ]; then
TMP="/tmp"
else
TMP="${TMPDIR%/}"
fi
# Not create `system/envs` directory even if source version is `system`
if [[ "${VERSION_NAME%/envs/*}" == "system" ]]; then
VIRTUALENV_NAME="${VIRTUALENV_NAME##*/}"
else
VIRTUALENV_PREFIX="$(pyenv-virtualenv-prefix 2>/dev/null || true)"
if [[ "${VIRTUALENV_PREFIX%/*}" == "${PYENV_ROOT}/versions" ]]; then
VIRTUALENV_NAME="${VIRTUALENV_PREFIX#${PYENV_ROOT}/versions/}/envs/${VIRTUALENV_NAME##*/}"
else
VIRTUALENV_NAME="${VERSION_NAME}/envs/${VIRTUALENV_NAME##*/}"
fi
fi
VIRTUALENV_PATH="${PYENV_ROOT}/versions/${VIRTUALENV_NAME}"
if [[ "${VIRTUALENV_PATH/*/envs/*}" != "${PYENV_ROOT}/versions" ]]; then
COMPAT_VIRTUALENV_PATH="${PYENV_ROOT}/versions/${VIRTUALENV_NAME##*/}"
fi
if [ -n "${COMPAT_VIRTUALENV_PATH}" ]; then
if [ -z ${FORCE} ]; then
if [ -e "${COMPAT_VIRTUALENV_PATH}" ] || [ -L "${COMPAT_VIRTUALENV_PATH}" ]; then
echo "pyenv-virtualenv: \`${COMPAT_VIRTUALENV_PATH}' already exists." 1>&2
exit 1
fi
fi
fi
unset HAS_VIRTUALENV
unset HAS_M_VENV
unset USE_CONDA
unset USE_M_VENV
detect_venv
SEED="$(date "+%Y%m%d%H%M%S").$$"
VIRTUALENV_ORIG="${VIRTUALENV_PATH}.${SEED}"
REQUIREMENTS="${TMP}/requirements.${SEED}.txt"
# Upgrade existing virtualenv
if [ -n "$UPGRADE" ]; then
FORCE=1
# `python -m venv` has `--upgrade` by default
if [ -n "${USE_M_VENV}" ]; then
unset UPGRADE
VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--upgrade"
fi
fi
if [ -z "${VIRTUALENV_VERSION}" ]; then
case "${PYENV_VERSION}" in
"3.0"* )
NO_ENSUREPIP=1
;;
"3.1"* )
NO_ENSUREPIP=1
;;
"3.2"* | "stackless-3.2"* )
# pip 8.x (bundled with virtualenv 14+) doesn't support 3.2 anymore
# https://github.com/yyuu/pyenv/issues/531
VIRTUALENV_VERSION="13.1.2"
NO_ENSUREPIP=1
;;
esac
fi
if [ -n "${USE_CONDA}" ]; then
# e.g. `conda create -n py35 python=3.5 anaconda`
if [ -n "${VIRTUALENV_PYTHON}" ]; then
VIRTUALENV_PYTHON="${VIRTUALENV_PYTHON##*/}"
VIRTUALENV_PYTHON="${VIRTUALENV_PYTHON#python}"
if [ -n "${VIRTUALENV_PYTHON}" ]; then
VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="python=${VIRTUALENV_PYTHON}"
fi
fi
else
if [ -n "${USE_M_VENV}" ]; then
# Unset some arguments not supported by `python -m venv`
unset QUIET
unset VERBOSE
if [ -n "${VIRTUALENV_PYTHON}" ]; then
echo "pyenv-virtualenv: \`--python=${VIRTUALENV_PYTHON}' is not supported by \`python -m venv'." 1>&2
exit 1
fi
else
if [ -n "${VIRTUALENV_PYTHON}" ]; then
if [[ "${VIRTUALENV_PYTHON}" == "${VIRTUALENV_PYTHON##*/}" ]] || [[ "${VIRTUALENV_PYTHON}" == "${PYENV_ROOT}/shims/"* ]]; then
python="$(pyenv-which "${VIRTUALENV_PYTHON##*/}" 2>/dev/null || true)"
if [ -x "${python}" ]; then
VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${python}"
else
python="$(PYENV_VERSION="$(pyenv-whence "${VIRTUALENV_PYTHON##*/}" 2>/dev/null | tail -n 1 || true)" pyenv-which "${VIRTUALENV_PYTHON##*/}" 2>/dev/null || true)"
if [ -x "${python}" ]; then
VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${python}"
else
# echo "pyenv-virtualenv: \`${VIRTUALENV_PYTHON##*/}' is not installed in pyenv." 1>&2
not_installed_message "${VIRTUALENV_PYTHON##*/}"
exit 1
fi
fi
else
VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${VIRTUALENV_PYTHON}"
fi
fi
if [ -z "${HAS_VIRTUALENV}" ]; then
if [ -n "${VIRTUALENV_VERSION}" ]; then
virtualenv_spec="virtualenv==${VIRTUALENV_VERSION}"
else
virtualenv_spec="virtualenv"
fi
pyenv-exec pip install $QUIET $VERBOSE "${virtualenv_spec}"
HAS_VIRTUALENV=1
fi
fi
fi
# Unset environment variables which start with `VIRTUALENV_`.
# These variables are reserved for virtualenv.
unset VIRTUALENV_VERSION
# Download specified version of ez_setup.py/get-pip.py.
if [ -z "${EZ_SETUP_URL}" ]; then
if [ -n "${SETUPTOOLS_VERSION}" ]; then
EZ_SETUP_URL="https://bitbucket.org/pypa/setuptools/raw/${SETUPTOOLS_VERSION}/ez_setup.py"
unset SETUPTOOLS_VERSION
else
EZ_SETUP_URL="https://bootstrap.pypa.io/ez_setup.py"
fi
fi
if [ -z "${GET_PIP_URL}" ]; then
if [ -n "${PIP_VERSION}" ]; then
{ colorize 1 "WARNING"
echo ": Setting PIP_VERSION=${PIP_VERSION} is no longer supported and may cause failures during the install process."
} 1>&2
GET_PIP_URL="https://raw.githubusercontent.com/pypa/pip/${PIP_VERSION}/contrib/get-pip.py"
# Unset `PIP_VERSION` from environment before invoking `get-pip.py` to deal with "ValueError: invalid truth value" (pypa/pip#4528)
unset PIP_VERSION
else
# Use custom get-pip URL based on the target version (#1127)
case "${PYENV_VERSION}" in
2.6 | 2.6.* )
GET_PIP_URL="https://bootstrap.pypa.io/pip/2.6/get-pip.py"
;;
2.7 | 2.7.* )
GET_PIP_URL="https://bootstrap.pypa.io/pip/2.7/get-pip.py"
;;
3.2 | 3.2.* )
GET_PIP_URL="https://bootstrap.pypa.io/pip/3.2/get-pip.py"
;;
3.3 | 3.3.* )
GET_PIP_URL="https://bootstrap.pypa.io/pip/3.3/get-pip.py"
;;
3.4 | 3.4.* )
GET_PIP_URL="https://bootstrap.pypa.io/pip/3.4/get-pip.py"
;;
3.5 | 3.5.* )
GET_PIP_URL="https://bootstrap.pypa.io/pip/3.5/get-pip.py"
;;
3.6 | 3.6.* )
GET_PIP_URL="https://bootstrap.pypa.io/pip/3.6/get-pip.py"
;;
* )
GET_PIP_URL="https://bootstrap.pypa.io/pip/get-pip.py"
;;
esac
fi
fi
# Define `before_virtualenv` and `after_virtualenv` functions that allow
# plugin hooks to register a string of code for execution before or
# after the installation process.
declare -a before_hooks after_hooks
before_virtualenv() {
local hook="$1"
before_hooks["${#before_hooks[@]}"]="$hook"
}
after_virtualenv() {
local hook="$1"
after_hooks["${#after_hooks[@]}"]="$hook"
}
# Load plugin hooks.
OLDIFS="$IFS"
IFS=$'\n' scripts=(`pyenv-hooks virtualenv`)
IFS="$OLDIFS"
for script in "${scripts[@]}"; do source "$script"; done
[ -d "${VIRTUALENV_PATH}" ] && PREFIX_EXISTS=1
# If the virtualenv exists, prompt for confirmation unless
# the --force option was specified.
if [ -d "${VIRTUALENV_PATH}/bin" ]; then
if [ -z "$FORCE" ]; then
echo "pyenv-virtualenv: ${VIRTUALENV_PATH} already exists" 1>&2
read -p "continue with installation? (y/N) "
case "$REPLY" in
y* | Y* ) ;;
* ) exit 1 ;;
esac
fi
if [ -n "$UPGRADE" ]; then
if [ -n "${NO_ENSUREPIP}" ]; then
echo "pyenv-virtualenv: upgrading will not work with --no-setuptools or --no-pip" 1>&2
exit 1
else
PYENV_VERSION="${VIRTUALENV_NAME}" prepare_requirements
fi
fi
fi
# Execute `before_virtualenv` hooks.
for hook in "${before_hooks[@]}"; do eval "$hook"; done
# Plan cleanup on unsuccessful installation.
cleanup() {
[[ -L "${COMPAT_VIRTUALENV_PATH}" ]] && rm "${COMPAT_VIRTUALENV_PATH}"
[ -z "${PREFIX_EXISTS}" ] && rm -rf "$VIRTUALENV_PATH"
}
trap cleanup SIGINT ERR
# Invoke virtualenv and record exit status in $STATUS.
STATUS=0
# virtualenv may download distribute/setuptools into the current directory.
# Change to cache directory to reuse them between invocations.
mkdir -p "${PYENV_VIRTUALENV_CACHE_PATH}"
cd "${PYENV_VIRTUALENV_CACHE_PATH}"
if [ -n "${USE_CONDA}" ]; then
if [ -z "$VIRTUALENV_PYTHON" ]; then
#process substitution doesn't seem to work unless it's directly inserted to the command line
#if we add it to VIRTUALENV_OPTIONS instead, "broken pipe" happens
pyenv-exec conda create $QUIET $VERBOSE --name "${VIRTUALENV_PATH##*/}" --yes "${VIRTUALENV_OPTIONS[@]}" --file <(pyenv-exec conda list python --full-name --export) || STATUS="$?"
else
pyenv-exec conda create $QUIET $VERBOSE --name "${VIRTUALENV_PATH##*/}" --yes "${VIRTUALENV_OPTIONS[@]}" || STATUS="$?"
fi
else
if [ -n "${USE_M_VENV}" ]; then
pyenv-exec "${M_VENV_PYTHON_BIN:-python}" -m venv $QUIET $VERBOSE "${VIRTUALENV_OPTIONS[@]}" "${VIRTUALENV_PATH}" || STATUS="$?"
else
pyenv-exec virtualenv $QUIET $VERBOSE "${VIRTUALENV_OPTIONS[@]}" "${VIRTUALENV_PATH}" || STATUS="$?"
fi
fi
(
shopt -s nullglob
for extra_binary in "$PREFIX"/bin/python*-config; do
extra_binary_linkname="$VIRTUALENV_PATH/bin/$(basename $extra_binary)"
[[ -e "$extra_binary_linkname" ]] || \
ln -s "$extra_binary" "$extra_binary_linkname"
done
)
## Create symlink in the `versions` directory for backward compatibility
if [ -d "${VIRTUALENV_PATH}" ] && [ -n "${COMPAT_VIRTUALENV_PATH}" ]; then
# Overwrite an existing link, can happen if running with -f
ln -fsn "${VIRTUALENV_PATH}" "${COMPAT_VIRTUALENV_PATH}"
fi
if [ ! -e "${VIRTUALENV_PATH}/bin/pydoc" ]; then
mkdir -p "${VIRTUALENV_PATH}/bin"
cat <<EOS > "${VIRTUALENV_PATH}/bin/pydoc"
#!${VIRTUALENV_PATH}/bin/python
import pydoc
if __name__ == '__main__':
pydoc.cli()
EOS
chmod +x "${VIRTUALENV_PATH}/bin/pydoc"
fi
if [ -z "${NO_ENSUREPIP}" ]; then
## Install setuptools and pip.
PYENV_VERSION="${VIRTUALENV_NAME}" build_package_ensurepip
## Migrate previously installed packages from requirements.txt.
PYENV_VERSION="${VIRTUALENV_NAME}" install_requirements || true
fi
# Execute `after_virtualenv` hooks.
for hook in "${after_hooks[@]}"; do eval "$hook"; done
# Run `pyenv-rehash` after a successful installation.
if [ "$STATUS" == "0" ]; then
pyenv-rehash
else
cleanup
fi
exit "$STATUS"
================================================
FILE: bin/pyenv-virtualenv-delete
================================================
#!/usr/bin/env bash
#
# Summary: Uninstall a specific Python virtualenv
#
# Usage: pyenv virtualenv-delete [-f|--force] <virtualenv>
#
# -f Attempt to remove the specified virtualenv without prompting
# for confirmation. If the virtualenv does not exist, do not
# display an error message.
#
# See `pyenv virtualenvs` for a complete list of installed versions.
#
set -e
[ -n "$PYENV_DEBUG" ] && set -x
if [ -z "${PYENV_ROOT}" ]; then
PYENV_ROOT="$(pyenv-root)"
fi
# Provide pyenv completions
if [ "$1" = "--complete" ]; then
exec pyenv virtualenvs --bare
fi
resolve_link() {
$(type -p greadlink readlink | head -1) "$1"
}
usage() {
pyenv-help virtualenv-delete 2>/dev/null
[ -z "$1" ] || exit "$1"
}
if [ -z "$PYENV_ROOT" ]; then
PYENV_ROOT="${HOME}/.pyenv"
fi
if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
usage 0
fi
unset FORCE
if [ "$1" = "-f" ] || [ "$1" = "--force" ]; then
FORCE=true
shift
fi
[ "$#" -eq 1 ] || usage 1 >&2
DEFINITION="$1"
case "$DEFINITION" in
"" | -* )
usage 1 >&2
;;
esac
VERSION_NAME="${DEFINITION##*/}"
# Must initialize because it might be set in the environment
ENV_PREFIX=
ENV_COMPAT_PREFIX="${PYENV_ROOT}/versions/${VERSION_NAME}"
if [[ "${DEFINITION}" != "${DEFINITION%/envs/*}" ]]; then
ENV_PREFIX="${PYENV_ROOT}/versions/${DEFINITION}"
if [ -L "${ENV_COMPAT_PREFIX}" ]; then
if [[ "${ENV_PREFIX}" != "$(resolve_link "${ENV_COMPAT_PREFIX}" 2>/dev/null || true)" ]]; then
unset ENV_COMPAT_PREFIX
fi
fi
else
if [ -L "${ENV_COMPAT_PREFIX}" ]; then
ENV_PREFIX="$(resolve_link "${ENV_COMPAT_PREFIX}" 2>/dev/null || true)"
if [[ "${ENV_PREFIX%/*/envs/*}" != "${PYENV_ROOT}/versions" ]]; then
echo "pyenv-virtualenv: \`${ENV_COMPAT_PREFIX}' is a symlink for unknown location." 1>&2
exit 1
fi
else
if pyenv-virtualenv-prefix "${VERSION_NAME}" 1>/dev/null 2>&1; then
ENV_PREFIX="${PYENV_ROOT}/versions/${VERSION_NAME}"
unset ENV_COMPAT_PREFIX
elif [ -z "$FORCE" ]; then
echo "pyenv-virtualenv: \`${DEFINITION}' is not a virtualenv." 1>&2
exit 1
fi
fi
fi
if [ ! -d "$ENV_PREFIX" ]; then
if [ -z "$FORCE" ]; then
echo "pyenv-virtualenv: virtualenv \`$VERSION_NAME' not installed" >&2
exit 1
else
exit 0
fi
fi
if [ -z "$FORCE" ]; then
read -p "pyenv-virtualenv: remove $ENV_PREFIX? (y/N) "
case "$REPLY" in
y* | Y* ) ;;
* ) exit 1 ;;
esac
fi
rm -rf "$ENV_PREFIX"
if [ -L "$ENV_COMPAT_PREFIX" ]; then
rm -rf "$ENV_COMPAT_PREFIX"
fi
pyenv-rehash
================================================
FILE: bin/pyenv-virtualenv-init
================================================
#!/usr/bin/env bash
# Summary: Configure the shell environment for pyenv-virtualenv
# Usage: eval "$(pyenv virtualenv-init - [<shell>])"
#
# Automatically activates a Python virtualenv environment based on current
# pyenv version.
#
set -e
[ -n "$PYENV_DEBUG" ] && set -x
resolve_link() {
$(type -p greadlink readlink | head -1) "$1"
}
abs_dirname() {
local cwd="$(pwd)"
local path="$1"
while [ -n "$path" ]; do
cd "${path%/*}"
local name="${path##*/}"
path="$(resolve_link "$name" || true)"
done
pwd
cd "$cwd"
}
PYENV_VIRTUALENV_INSTALL_PREFIX="$(dirname "$(abs_dirname "$0")")"
print=""
for args in "$@"
do
if [ "$args" = "-" ]; then
print=1
shift
fi
done
shell="${1:-$PYENV_SHELL}"
if [ -z "$shell" ]; then
shell="$(ps -p "$PPID" -o 'args=' 2>/dev/null || true)"
shell="${shell##-}"
shell="${shell%% *}"
shell="${shell:-$SHELL}"
shell="${shell##*/}"
shell="${shell%%-*}"
fi
if [ -z "$print" ]; then
case "$shell" in
bash )
profile='~/.bashrc'
;;
zsh )
profile='~/.zshrc'
;;
ksh )
profile='~/.profile'
;;
fish )
profile='~/.config/fish/config.fish'
;;
* )
profile='your profile'
;;
esac
{ echo "# Load pyenv-virtualenv automatically by adding"
echo "# the following to ${profile}:"
echo
case "$shell" in
fish )
echo 'status --is-interactive; and source (pyenv virtualenv-init -|psub)'
;;
* )
echo 'eval "$(pyenv virtualenv-init -)"'
;;
esac
echo
} >&2
exit 1
fi
case "$shell" in
fish )
cat <<EOS
while set index (contains -i -- "${PYENV_VIRTUALENV_ROOT:-${PYENV_VIRTUALENV_INSTALL_PREFIX}}/shims" \$PATH)
set -eg PATH[\$index]; end; set -e index
set -gx PATH '${PYENV_VIRTUALENV_ROOT:-${PYENV_VIRTUALENV_INSTALL_PREFIX}}/shims' \$PATH;
set -gx PYENV_VIRTUALENV_INIT 1;
EOS
;;
* )
cat <<EOS
export PATH="${PYENV_VIRTUALENV_ROOT:-${PYENV_VIRTUALENV_INSTALL_PREFIX}}/shims:\${PATH}";
export PYENV_VIRTUALENV_INIT=1;
EOS
;;
esac
case "$shell" in
fish )
cat <<EOS
function _pyenv_virtualenv_hook --on-event fish_prompt;
set -l ret \$status
if [ -n "\$VIRTUAL_ENV" ]
pyenv activate --quiet; or pyenv deactivate --quiet; or true
else
pyenv activate --quiet; or true
end
return \$ret
end
EOS
;;
ksh )
cat <<EOS
function _pyenv_virtualenv_hook() {
EOS
;;
* )
cat <<EOS
_pyenv_virtualenv_hook() {
EOS
;;
esac
if [[ "$shell" != "fish" ]]; then
cat <<EOS
local ret=\$?
if [ -n "\${VIRTUAL_ENV-}" ]; then
eval "\$(pyenv sh-activate --quiet || pyenv sh-deactivate --quiet || true)" || true
else
eval "\$(pyenv sh-activate --quiet || true)" || true
fi
return \$ret
};
EOS
case "$shell" in
bash )
cat <<EOS
if ! [[ "\${PROMPT_COMMAND-}" =~ _pyenv_virtualenv_hook ]]; then
PROMPT_COMMAND="_pyenv_virtualenv_hook;\${PROMPT_COMMAND-}"
fi
EOS
;;
zsh )
cat <<EOS
typeset -g -a precmd_functions
if [[ -z \$precmd_functions[(r)_pyenv_virtualenv_hook] ]]; then
precmd_functions=(_pyenv_virtualenv_hook \$precmd_functions);
fi
EOS
;;
* )
# FIXME: what should i do here??
;;
esac
fi
================================================
FILE: bin/pyenv-virtualenv-prefix
================================================
#!/usr/bin/env bash
#
# Summary: Display real_prefix for a Python virtualenv version
# Usage: pyenv virtualenv-prefix [<virtualenv>]
#
set -e
[ -n "$PYENV_DEBUG" ] && set -x
if [ -L "${BASH_SOURCE}" ]; then
READLINK=$(type -p greadlink readlink | head -1)
if [ -z "$READLINK" ]; then
echo "pyenv: cannot find readlink - are you missing GNU coreutils?" >&2
exit 1
fi
resolve_link() {
$READLINK -f "$1"
}
script_path=$(resolve_link ${BASH_SOURCE})
else
script_path=${BASH_SOURCE}
fi
. ${script_path%/*}/../libexec/pyenv-virtualenv-realpath
if [ -z "$PYENV_ROOT" ]; then
PYENV_ROOT="${HOME}/.pyenv"
fi
if [ -n "$1" ]; then
versions=($@)
IFS=: PYENV_VERSION="${versions[*]}"
export PYENV_VERSION
else
IFS=: versions=($(pyenv-version-name))
fi
append_virtualenv_prefix() {
if [ -d "${VIRTUALENV_PREFIX_PATH}" ]; then
VIRTUALENV_PREFIX_PATHS=("${VIRTUALENV_PREFIX_PATHS[@]}" "${VIRTUALENV_PREFIX_PATH:-${PYENV_PREFIX_PATH}}")
else
echo "pyenv-virtualenv: version \`${version}' is not a virtualenv" 1>&2
exit 1
fi
}
VIRTUALENV_PREFIX_PATHS=()
for version in "${versions[@]}"; do
if [ "$version" = "system" ]; then
echo "pyenv-virtualenv: version \`${version}' is not a virtualenv" 1>&2
exit 1
fi
PYENV_PREFIX_PATH="$(pyenv-prefix "${version}")"
if [ -x "${PYENV_PREFIX_PATH}/bin/python" ]; then
if [ -f "${PYENV_PREFIX_PATH}/bin/activate" ]; then
if [ -f "${PYENV_PREFIX_PATH}/bin/conda" ]; then
# conda
VIRTUALENV_PREFIX_PATH="${PYENV_PREFIX_PATH}"
else
if [ -f "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" ]; then
# venv
virtualenv_binpath="$(cut -b 1-1024 "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" | sed -n '/^ *home *= */s///p' || true)"
VIRTUALENV_PREFIX_PATH="${virtualenv_binpath%/bin}"
else
# virtualenv
if [ -d "${PYENV_ROOT}/versions/${version}/Lib" ]; then
# jython
virtualenv_libpath="${PYENV_ROOT}/versions/${version}/Lib"
else
if [ -d "${PYENV_ROOT}/versions/${version}/lib-python" ]; then
# pypy
virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib-python"
else
virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib"
fi
fi
virtualenv_orig_prefix="$(find "${virtualenv_libpath}/" -maxdepth 2 -type f -and -name "orig-prefix.txt" 2>/dev/null | head -1)"
if [ -f "${virtualenv_orig_prefix}" ]; then
VIRTUALENV_PREFIX_PATH="$(cat "${virtualenv_orig_prefix}" 2>/dev/null || true)"
fi
fi
fi
append_virtualenv_prefix
elif [ -d "${PYENV_PREFIX_PATH}/conda-meta" ]; then
# conda
VIRTUALENV_PREFIX_PATH="$(realpath "${PYENV_PREFIX_PATH}"/../..)"
append_virtualenv_prefix
else
echo "pyenv-virtualenv: version \`${version}' is not a virtualenv" 1>&2
exit 1
fi
else
echo "pyenv-virtualenv: \`python' not found in version \`${version}'" 1>&2
exit 1
fi
done
IFS=: echo "${VIRTUALENV_PREFIX_PATHS[*]}"
================================================
FILE: bin/pyenv-virtualenvs
================================================
#!/usr/bin/env bash
#
# Summary: List all Python virtualenvs found in `$PYENV_ROOT/versions/*'.
# Usage: pyenv virtualenvs [--bare] [--skip-aliases]
#
# List all virtualenvs found in `$PYENV_ROOT/versions/*' and its `$PYENV_ROOT/versions/envs/*'.
set -e
[ -n "$PYENV_DEBUG" ] && set -x
if [ -L "${BASH_SOURCE}" ]; then
READLINK=$(type -p greadlink readlink | head -1)
if [ -z "$READLINK" ]; then
echo "pyenv: cannot find readlink - are you missing GNU coreutils?" >&2
exit 1
fi
resolve_link() {
$READLINK -f "$1"
}
script_path=$(resolve_link ${BASH_SOURCE})
else
script_path=${BASH_SOURCE}
fi
. ${script_path%/*}/../libexec/pyenv-virtualenv-realpath
if [ -z "$PYENV_ROOT" ]; then
PYENV_ROOT="${HOME}/.pyenv"
fi
unset bare
unset skip_aliases
# Provide pyenv completions
for arg; do
case "$arg" in
--complete )
echo --bare
echo --skip-aliases
exit ;;
--bare ) bare=1 ;;
--skip-aliases ) skip_aliases=1 ;;
* )
pyenv-help --usage virtualenvs >&2
exit 1
;;
esac
done
versions_dir="${PYENV_ROOT}/versions"
if [ -d "$versions_dir" ]; then
versions_dir="$(realpath "$versions_dir")"
fi
if [ -n "$bare" ]; then
hit_prefix=""
miss_prefix=""
current_versions=()
unset print_origin
include_system=""
else
hit_prefix="* "
miss_prefix=" "
OLDIFS="$IFS"
IFS=: current_versions=($(pyenv-version-name || true))
IFS="$OLDIFS"
print_origin="1"
include_system=""
fi
num_versions=0
exists() {
local car="$1"
local cdar
shift
for cdar in "$@"; do
if [ "${car}" == "${cdar}" ]; then
return 0
fi
done
return 1
}
print_version() {
if exists "$1" "${current_versions[@]}"; then
echo "${hit_prefix}${1}${print_origin+$2}"
else
echo "${miss_prefix}${1}${print_origin+$2}"
fi
num_versions=$((num_versions + 1))
}
shopt -s dotglob
shopt -s nullglob
for path in "$versions_dir"/*; do
if [ -d "$path" ]; then
if [ -n "$skip_aliases" ] && [ -L "$path" ]; then
target="$(realpath "$path")"
[ "${target%/*/envs/*}" != "$versions_dir" ] || continue
fi
virtualenv_prefix="$(pyenv-virtualenv-prefix "${path##*/}" 2>/dev/null || true)"
if [ -d "${virtualenv_prefix}" ]; then
print_version "${path##*/}" " (created from ${virtualenv_prefix})"
fi
for venv_path in "${path}/envs/"*; do
venv="${path##*/}/envs/${venv_path##*/}"
virtualenv_prefix="$(pyenv-virtualenv-prefix "${venv}" 2>/dev/null || true)"
if [ -d "${virtualenv_prefix}" ]; then
print_version "${venv}" " (created from ${virtualenv_prefix})"
fi
done
fi
done
shopt -u dotglob
shopt -u nullglob
if [ "$num_versions" -eq 0 ] && [ -n "$include_system" ]; then
echo "Warning: no Python virtualenv detected on the system" >&2
exit 1
fi
================================================
FILE: etc/pyenv.d/rehash/envs.bash
================================================
virtualenv_list_executable_names() {
local file
shopt -s nullglob
for file in "$PYENV_ROOT"/versions/*/envs/*/bin/*; do
echo "${file##*/}"
done
shopt -u nullglob
}
if declare -f make_shims 1>/dev/null 2>&1; then
make_shims $(virtualenv_list_executable_names | sort -u)
fi
================================================
FILE: etc/pyenv.d/uninstall/envs.bash
================================================
resolve_link() {
$(type -p greadlink readlink | head -1) "$1"
}
uninstall_related_virtual_env() {
if [ -n "${DEFINITION}" ]; then
if [[ "${DEFINITION}" != "${DEFINITION%/envs/*}" ]]; then
# Uninstall virtualenv by long name
pyenv-virtualenv-delete ${FORCE+-f} "${DEFINITION}"
else
VERSION_NAME="${VERSION_NAME:-${DEFINITION##*/}}"
PREFIX="${PREFIX:-${PYENV_ROOT}/versions/${VERSION_NAME}}"
if [ -L "${PREFIX}" ]; then
REAL_PREFIX="$(resolve_link "${PREFIX}" 2>/dev/null || true)"
REAL_DEFINITION="${REAL_PREFIX#${PYENV_ROOT}/versions/}"
if [[ "${REAL_DEFINITION}" != "${REAL_DEFINITION%/envs/*}" ]]; then
# Uninstall virtualenv by short name
pyenv-virtualenv-delete ${FORCE+-f} "${REAL_DEFINITION}"
fi
else
# Uninstall all virtualenvs inside `envs` directory too
shopt -s nullglob
for virtualenv in "${PREFIX}/envs/"*; do
pyenv-virtualenv-delete ${FORCE+-f} "${DEFINITION}/envs/${virtualenv##*/}"
done
shopt -u nullglob
fi
fi
fi
}
before_uninstall "uninstall_related_virtual_env"
================================================
FILE: etc/pyenv.d/which/conda.bash
================================================
# newer versions of conda share programs from the real prefix
# this hook tries to find the executable there
if [ ! -x "${PYENV_COMMAND_PATH}" ] && [[ "${PYENV_COMMAND_PATH##*/}" == "conda" ]]; then
if [ -d "${PYENV_ROOT}/versions/${version}/conda-meta" ]; then
conda_command_path="$(pyenv-virtualenv-prefix "$version")"/bin/"${PYENV_COMMAND_PATH##*/}"
if [ -x "${conda_command_path}" ]; then
PYENV_COMMAND_PATH="${conda_command_path}"
fi
fi
fi
================================================
FILE: etc/pyenv.d/which/python-config.bash
================================================
# some of libraries require `python-config` in PATH to build native extensions.
# as a workaround, this hook will try to find the executable from the source
# version of the virtualenv.
# https://github.com/yyuu/pyenv/issues/397
if [ ! -x "${PYENV_COMMAND_PATH}" ] && [[ "${PYENV_COMMAND_PATH##*/}" == "python"*"-config" ]]; then
OLDIFS="${IFS}"
IFS=:
version="$(pyenv-version-name)"
IFS="${OLDIFS}"
if [ -f "${PYENV_ROOT}/versions/${version}/bin/activate" ]; then
if [ -f "${PYENV_ROOT}/versions/${version}/bin/conda" ]; then
: # do nothing for conda's environments
else
if [ -f "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" ]; then
# venv
virtualenv_binpath="$(cut -b 1-1024 "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" | sed -n '/^ *home *= */s///p' || true)"
virtualenv_prefix="${virtualenv_binpath%/bin}"
else
# virtualenv
if [ -d "${PYENV_ROOT}/versions/${version}/Lib" ]; then
# jython
virtualenv_libpath="${PYENV_ROOT}/versions/${version}/Lib"
else
if [ -d "${PYENV_ROOT}/versions/${version}/lib-python" ]; then
# pypy
virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib-python"
else
virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib"
fi
fi
virtualenv_orig_prefix="$(find "${virtualenv_libpath}/" -maxdepth 2 -type f -and -name "orig-prefix.txt" 2>/dev/null | head -1)"
if [ -f "${virtualenv_orig_prefix}" ]; then
virtualenv_prefix="$(cat "${virtualenv_orig_prefix}" 2>/dev/null || true)"
fi
fi
virtualenv_command_path="${virtualenv_prefix}/bin/${PYENV_COMMAND_PATH##*/}"
if [ -x "${virtualenv_command_path}" ]; then
PYENV_COMMAND_PATH="${virtualenv_command_path}"
fi
fi
fi
fi
================================================
FILE: etc/pyenv.d/which/system-site-packages.bash
================================================
# if virtualenv is created with `--system-site-packages`,
# looks up executables for source version as well if none is
# installed in the virtualenv.
# https://github.com/yyuu/pyenv-virtualenv/issues/62
if [ ! -x "${PYENV_COMMAND_PATH}" ]; then
OLDIFS="${IFS}"
IFS=:
version="$(pyenv-version-name)"
IFS="${OLDIFS}"
if [ -f "${PYENV_ROOT}/versions/${version}/bin/activate" ]; then
unset include_system_site_packages
if [ -f "${PYENV_ROOT}/versions/${version}/bin/conda" ]; then
: # do nothing for conda's environments
else
if [ -f "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" ]; then
# venv
virtualenv_binpath="$(cut -b 1-1024 "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" | sed -n '/^ *home *= */s///p' || true)"
virtualenv_prefix="${virtualenv_binpath%/bin}"
if grep -q -i "include-system-site-packages *= *true" "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" 1>/dev/null 2>&1; then
include_system_site_packages=1
fi
else
# virtualenv
if [ -d "${PYENV_ROOT}/versions/${version}/Lib" ]; then
# jython
virtualenv_libpath="${PYENV_ROOT}/versions/${version}/Lib"
else
if [ -d "${PYENV_ROOT}/versions/${version}/lib-python" ]; then
# pypy
virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib-python"
else
virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib"
fi
fi
no_global_site_packages="$(find "${virtualenv_libpath}/" -maxdepth 2 -type f -and -name "no-global-site-packages.txt" 2>/dev/null | head -1)"
if [ ! -f "${no_global_site_packages}" ]; then
include_system_site_packages=1
fi
virtualenv_orig_prefix="$(find "${virtualenv_libpath}/" -maxdepth 2 -type f -and -name "orig-prefix.txt" 2>/dev/null | head -1)"
if [ -f "${virtualenv_orig_prefix}" ]; then
virtualenv_prefix="$(cat "${virtualenv_orig_prefix}" 2>/dev/null || true)"
fi
fi
if [ -n "${include_system_site_packages}" ] && [ -n "${virtualenv_prefix}" ]; then
# virtualenv is created with `--system-site-packages`
virtualenv_command_path="${virtualenv_prefix}/bin/${PYENV_COMMAND_PATH##*/}"
if [ -x "${virtualenv_command_path}" ]; then
PYENV_COMMAND_PATH="${virtualenv_command_path}"
fi
fi
fi
fi
fi
================================================
FILE: install.sh
================================================
#!/bin/sh
# Usage: PREFIX=/usr/local ./install.sh
#
# Installs pyenv-virtualenv under $PREFIX.
set -e
cd "$(dirname "$0")"
if [ -z "${PREFIX}" ]; then
PREFIX="/usr/local"
fi
BIN_PATH="${PREFIX}/bin"
LIBEXEC_PATH="${PREFIX}/libexec"
SHIMS_PATH="${PREFIX}/shims"
HOOKS_PATH="${PREFIX}/etc/pyenv.d"
mkdir -p "$BIN_PATH"
mkdir -p "$LIBEXEC_PATH"
mkdir -p "$SHIMS_PATH"
mkdir -p "$HOOKS_PATH"
install -p bin/* "$BIN_PATH"
install -p libexec/* "$LIBEXEC_PATH"
install -p shims/* "$SHIMS_PATH"
for hook in etc/pyenv.d/*; do
if [ -d "$hook" ]; then
cp -RPp "$hook" "$HOOKS_PATH"
else
install -p -m 0644 "$hook" "$HOOKS_PATH"
fi
done
================================================
FILE: libexec/pyenv-virtualenv-realpath
================================================
#!/usr/bin/env bash
# Summary: Substitute realpath if unavailable as a builtin or file
# Usage: . pyenv-virtualenv-realpath
if ! {
enable -f "${BASH_SOURCE%/*}"/../../../libexec/pyenv-realpath.dylib realpath ||
type realpath
} >/dev/null 2>&1; then
if [ -n "$PYENV_NATIVE_EXT" ]; then
echo "pyenv: failed to load \`realpath' builtin" >&2
exit 1
fi
READLINK=$(type -p greadlink readlink | head -1)
if [ -z "$READLINK" ]; then
echo "pyenv: cannot find readlink - are you missing GNU coreutils?" >&2
exit 1
fi
resolve_link() {
$READLINK "$1"
}
realpath() {
local f="$*" \
name dir
[[ $f ]] || {
>&2 echo ${FUNCNAME[0]}: missing operand
return
}
while [[ -L $f ]]; do
f="$(resolve_link "$f")"
done
if [[ ! -d $f ]]; then
name="/${f##*/}"
# parent?
dir="${f%/*}"
if [[ $dir == $f ]]; then
#lacks /: parent is current directory
f="$PWD"
else
f="$dir"
fi
fi
#absolute directory
dir="$(cd "$f"
pwd)"
echo "$dir$name"
}
fi
================================================
FILE: shims/activate
================================================
#!/usr/bin/env bash
if [[ "$0" != "${BASH_SOURCE}" ]]; then
eval "$(pyenv sh-activate --verbose "$@" || true)"
else
echo "pyenv-virtualenv: activate must be sourced. Run 'source activate envname' instead of 'activate envname'" 1>&2
false
fi
================================================
FILE: shims/deactivate
================================================
#!/usr/bin/env bash
if [[ "$0" != "${BASH_SOURCE}" ]]; then
eval "$(pyenv sh-deactivate --verbose "$@" || true)"
else
echo "pyenv-virtualenv: deactivate must be sourced. Run 'source deactivate' instead of 'deactivate'" 1>&2
false
fi
================================================
FILE: test/activate.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export HOME="${TMP}"
export PYENV_ROOT="${TMP}/pyenv"
unset PYENV_VERSION
unset PYENV_ACTIVATE_SHELL
unset VIRTUAL_ENV
unset CONDA_DEFAULT_ENV
unset PYTHONHOME
unset _OLD_VIRTUAL_PYTHONHOME
unset PYENV_VIRTUALENV_VERBOSE_ACTIVATE
unset PYENV_VIRTUALENV_DISABLE_PROMPT
unset PYENV_VIRTUAL_ENV_DISABLE_PROMPT
unset VIRTUAL_ENV_DISABLE_PROMPT
unset PYENV_VIRTUALENV_PROMPT
unset _OLD_VIRTUAL_PS1
stub pyenv-hooks "activate : echo"
}
@test "activate virtualenv from current version" {
export PYENV_VIRTUALENV_INIT=1
stub pyenv-version-name "echo venv"
stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate
assert_success
assert_output <<EOS
deactivated
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(venv) \${PS1:-}";
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from current version with custom prompt" {
export PYENV_VIRTUALENV_INIT=1
stub pyenv-version-name "echo venv"
stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="venv" PYENV_VIRTUALENV_PROMPT='venv:{venv}' run pyenv-sh-activate
assert_success
assert_output <<EOS
deactivated
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="venv:venv \${PS1:-}";
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from current version (quiet)" {
export PYENV_VIRTUALENV_INIT=1
stub pyenv-version-name "echo venv"
stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate --quiet
assert_success
assert_output <<EOS
deactivated
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(venv) \${PS1:-}";
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from current version (verbose)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUALENV_VERBOSE_ACTIVATE=1
stub pyenv-version-name "echo venv"
stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate --verbose
assert_success
assert_output <<EOS
deactivated
pyenv-virtualenv: activate venv
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(venv) \${PS1:-}";
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from current version (without pyenv-virtualenv-init)" {
export PYENV_VIRTUALENV_INIT=
stub pyenv-version-name "echo venv"
stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate
assert_success
assert_output <<EOS
deactivated
export PYENV_VERSION="venv";
export PYENV_ACTIVATE_SHELL=1;
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(venv) \${PS1:-}";
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from current version (fish)" {
export PYENV_VIRTUALENV_INIT=1
stub pyenv-version-name "echo venv"
stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate
assert_success
assert_output <<EOS
deactivated
set -gx PYENV_VIRTUAL_ENV "${PYENV_ROOT}/versions/venv";
set -gx VIRTUAL_ENV "${PYENV_ROOT}/versions/venv";
functions -e _pyenv_old_prompt # remove old prompt function if exists.
# since everything is in memory, it's safe to
# remove it.
functions -c fish_prompt _pyenv_old_prompt # backup old prompt function
# from python-venv
function fish_prompt
set -l prompt (_pyenv_old_prompt) # call old prompt function first since it might
# read exit status
echo -n "(venv) " # add virtualenv to prompt
string join -- \n \$prompt # handle multiline prompts
end
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from current version (fish) (without pyenv-virtualenv-init)" {
export PYENV_VIRTUALENV_INIT=
stub pyenv-version-name "echo venv"
stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate
assert_success
assert_output <<EOS
deactivated
set -gx PYENV_VERSION "venv";
set -gx PYENV_ACTIVATE_SHELL 1;
set -gx PYENV_VIRTUAL_ENV "${PYENV_ROOT}/versions/venv";
set -gx VIRTUAL_ENV "${PYENV_ROOT}/versions/venv";
functions -e _pyenv_old_prompt # remove old prompt function if exists.
# since everything is in memory, it's safe to
# remove it.
functions -c fish_prompt _pyenv_old_prompt # backup old prompt function
# from python-venv
function fish_prompt
set -l prompt (_pyenv_old_prompt) # call old prompt function first since it might
# read exit status
echo -n "(venv) " # add virtualenv to prompt
string join -- \n \$prompt # handle multiline prompts
end
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from command-line argument" {
export PYENV_VIRTUALENV_INIT=1
stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
assert_success
assert_output <<EOS
deactivated
export PYENV_VERSION="venv27";
export PYENV_ACTIVATE_SHELL=1;
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(venv27) \${PS1:-}";
EOS
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from command-line argument (without pyenv-virtualenv-init)" {
export PYENV_VIRTUALENV_INIT=
stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
assert_success
assert_output <<EOS
deactivated
export PYENV_VERSION="venv27";
export PYENV_ACTIVATE_SHELL=1;
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(venv27) \${PS1:-}";
EOS
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from command-line argument (fish)" {
export PYENV_VIRTUALENV_INIT=1
stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
assert_success
assert_output <<EOS
deactivated
set -gx PYENV_VERSION "venv27";
set -gx PYENV_ACTIVATE_SHELL 1;
set -gx PYENV_VIRTUAL_ENV "${PYENV_ROOT}/versions/venv27";
set -gx VIRTUAL_ENV "${PYENV_ROOT}/versions/venv27";
functions -e _pyenv_old_prompt # remove old prompt function if exists.
# since everything is in memory, it's safe to
# remove it.
functions -c fish_prompt _pyenv_old_prompt # backup old prompt function
# from python-venv
function fish_prompt
set -l prompt (_pyenv_old_prompt) # call old prompt function first since it might
# read exit status
echo -n "(venv27) " # add virtualenv to prompt
string join -- \n \$prompt # handle multiline prompts
end
EOS
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "activate virtualenv from command-line argument (fish) (without pyenv-virtualenv-init)" {
export PYENV_VIRTUALENV_INIT=
stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
assert_success
assert_output <<EOS
deactivated
set -gx PYENV_VERSION "venv27";
set -gx PYENV_ACTIVATE_SHELL 1;
set -gx PYENV_VIRTUAL_ENV "${PYENV_ROOT}/versions/venv27";
set -gx VIRTUAL_ENV "${PYENV_ROOT}/versions/venv27";
functions -e _pyenv_old_prompt # remove old prompt function if exists.
# since everything is in memory, it's safe to
# remove it.
functions -c fish_prompt _pyenv_old_prompt # backup old prompt function
# from python-venv
function fish_prompt
set -l prompt (_pyenv_old_prompt) # call old prompt function first since it might
# read exit status
echo -n "(venv27) " # add virtualenv to prompt
string join -- \n \$prompt # handle multiline prompts
end
EOS
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
}
@test "unset invokes deactivate" {
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=
stub pyenv-sh-deactivate " : echo deactivated"
run pyenv-sh-activate --unset
assert_success
assert_output <<EOS
deactivated
EOS
unstub pyenv-sh-deactivate
}
@test "should fail if the version is not a virtualenv" {
stub pyenv-virtualenv-prefix "3.3.3 : false"
stub pyenv-version-name " : echo 3.3.3"
stub pyenv-virtualenv-prefix "3.3.3/envs/3.3.3 : false"
run pyenv-sh-activate "3.3.3"
assert_failure
assert_output <<EOS
pyenv-virtualenv: version \`3.3.3' is not a virtualenv
false
EOS
unstub pyenv-virtualenv-prefix
unstub pyenv-version-name
}
@test "should fail if the version is not a virtualenv (quiet)" {
stub pyenv-virtualenv-prefix "3.3.3 : false"
stub pyenv-version-name " : echo 3.3.3"
stub pyenv-virtualenv-prefix "3.3.3/envs/3.3.3 : false"
run pyenv-sh-activate --quiet "3.3.3"
assert_failure
assert_output <<EOS
false
EOS
unstub pyenv-virtualenv-prefix
unstub pyenv-version-name
}
@test "should fail if there are multiple versions" {
stub pyenv-virtualenv-prefix "venv : true"
stub pyenv-virtualenv-prefix "venv27 : true"
run pyenv-sh-activate "venv" "venv27"
assert_failure
assert_output <<EOS
pyenv-virtualenv: cannot activate multiple versions at once: venv venv27
false
EOS
unstub pyenv-virtualenv-prefix
}
@test "should fail if there are multiple virtualenvs (quiet)" {
stub pyenv-virtualenv-prefix "venv : true"
stub pyenv-virtualenv-prefix "venv27 : true"
run pyenv-sh-activate --quiet "venv" "venv27"
assert_failure
assert_output <<EOS
false
EOS
unstub pyenv-virtualenv-prefix
}
@test "should fail if the first version is not a virtualenv" {
export PYENV_VIRTUALENV_INIT=1
stub pyenv-virtualenv-prefix "2.7.10 : false"
stub pyenv-version-name " : echo 2.7.10"
stub pyenv-virtualenv-prefix "2.7.10/envs/2.7.10 : false"
run pyenv-sh-activate "2.7.10" "venv27"
assert_failure
assert_output <<EOS
pyenv-virtualenv: version \`2.7.10' is not a virtualenv
false
EOS
unstub pyenv-virtualenv-prefix
unstub pyenv-version-name
}
@test "activate if the first virtualenv is a virtualenv" {
export PYENV_VIRTUALENV_INIT=1
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
stub pyenv-virtualenv-prefix "2.7.10 : false"
stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
PYENV_SHELL="bash" run pyenv-sh-activate "venv27" "2.7.10"
assert_success
assert_output <<EOS
deactivated
export PYENV_VERSION="venv27:2.7.10";
export PYENV_ACTIVATE_SHELL=1;
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(venv27) \${PS1:-}";
EOS
unstub pyenv-sh-deactivate
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
}
@test "do nothing if a 3rd-party virtualenv is active" {
export PYENV_VIRTUALENV_INIT=1
export VIRTUAL_ENV="${TMP}/venv-3rd-party"
unset PYENV_VIRTUAL_ENV
PYENV_SHELL="bash" run pyenv-sh-activate "venv"
assert_success
assert_output <<EOS
pyenv-virtualenv: virtualenv \`${TMP}/venv-3rd-party' is already activated
true
EOS
}
@test "do nothing if a 3rd-party virtualenv is active over ours" {
export PYENV_VIRTUALENV_INIT=1
export VIRTUAL_ENV="${TMP}/venv-3rd-party"
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
PYENV_SHELL="bash" run pyenv-sh-activate "venv"
assert_success
assert_output <<EOS
pyenv-virtualenv: virtualenv \`${TMP}/venv-3rd-party' is already activated
true
EOS
}
@test "should fail if activate is invoked as a command" {
run pyenv-activate
assert_failure
}
================================================
FILE: test/conda-activate.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export HOME="${TMP}"
export PYENV_ROOT="${TMP}/pyenv"
unset PYENV_VERSION
unset PYENV_ACTIVATE_SHELL
unset PYENV_VIRTUAL_ENV
unset VIRTUAL_ENV
unset CONDA_DEFAULT_ENV
unset PYTHONHOME
unset _OLD_VIRTUAL_PYTHONHOME
unset PYENV_VIRTUALENV_VERBOSE_ACTIVATE
unset PYENV_VIRTUALENV_DISABLE_PROMPT
unset PYENV_VIRTUAL_ENV_DISABLE_PROMPT
unset VIRTUAL_ENV_DISABLE_PROMPT
unset PYENV_VIRTUALENV_PROMPT
unset _OLD_VIRTUAL_PS1
stub pyenv-hooks "activate : echo"
}
teardown() {
unstub pyenv-hooks
}
@test "activate conda root from current version" {
export PYENV_VIRTUALENV_INIT=1
setup_conda "anaconda-2.3.0"
stub pyenv-version-name "echo anaconda-2.3.0"
stub pyenv-virtualenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0" run pyenv-sh-activate
assert_success
assert_output <<EOS
deactivated
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0";
export CONDA_DEFAULT_ENV="root";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(anaconda-2.3.0) \${PS1:-}";
export CONDA_PREFIX="${TMP}/pyenv/versions/anaconda-2.3.0";
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
teardown_conda "anaconda-2.3.0"
}
@test "activate conda root from current version with custom prompt" {
export PYENV_VIRTUALENV_INIT=1
setup_conda "anaconda-2.3.0"
stub pyenv-version-name "echo anaconda-2.3.0"
stub pyenv-virtualenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0" PYENV_VIRTUALENV_PROMPT='venv:{venv}' run pyenv-sh-activate
assert_success
assert_output <<EOS
deactivated
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0";
export CONDA_DEFAULT_ENV="root";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="venv:anaconda-2.3.0 \${PS1:-}";
export CONDA_PREFIX="${TMP}/pyenv/versions/anaconda-2.3.0";
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
teardown_conda "anaconda-2.3.0"
}
@test "activate conda root from current version (fish)" {
export PYENV_VIRTUALENV_INIT=1
setup_conda "anaconda-2.3.0"
stub pyenv-version-name "echo anaconda-2.3.0"
stub pyenv-virtualenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="fish" PYENV_VERSION="anaconda-2.3.0" run pyenv-sh-activate
assert_success
assert_output <<EOS
deactivated
set -gx PYENV_VIRTUAL_ENV "${TMP}/pyenv/versions/anaconda-2.3.0";
set -gx VIRTUAL_ENV "${TMP}/pyenv/versions/anaconda-2.3.0";
set -gx CONDA_DEFAULT_ENV "root";
functions -e _pyenv_old_prompt # remove old prompt function if exists.
# since everything is in memory, it's safe to
# remove it.
functions -c fish_prompt _pyenv_old_prompt # backup old prompt function
# from python-venv
function fish_prompt
set -l prompt (_pyenv_old_prompt) # call old prompt function first since it might
# read exit status
echo -n "(anaconda-2.3.0) " # add virtualenv to prompt
string join -- \n \$prompt # handle multiline prompts
end
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
teardown_conda "anaconda-2.3.0"
}
@test "activate conda root from command-line argument" {
export PYENV_VIRTUALENV_INIT=1
setup_conda "anaconda-2.3.0"
setup_conda "miniconda-3.9.1"
stub pyenv-virtualenv-prefix "miniconda-3.9.1 : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1\""
stub pyenv-prefix "miniconda-3.9.1 : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0" run pyenv-sh-activate "miniconda-3.9.1"
assert_success
assert_output <<EOS
deactivated
export PYENV_VERSION="miniconda-3.9.1";
export PYENV_ACTIVATE_SHELL=1;
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/miniconda-3.9.1";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/miniconda-3.9.1";
export CONDA_DEFAULT_ENV="root";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(miniconda-3.9.1) \${PS1:-}";
export CONDA_PREFIX="${TMP}/pyenv/versions/miniconda-3.9.1";
EOS
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
teardown_conda "anaconda-2.3.0"
teardown_conda "miniconda-3.9.1"
}
@test "activate conda env from current version" {
export PYENV_VIRTUALENV_INIT=1
setup_conda "anaconda-2.3.0" "foo"
stub pyenv-version-name "echo anaconda-2.3.0/envs/foo"
stub pyenv-virtualenv-prefix "anaconda-2.3.0/envs/foo : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo\""
stub pyenv-prefix "anaconda-2.3.0/envs/foo : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0/envs/foo" run pyenv-sh-activate
assert_success
assert_output <<EOS
deactivated
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo";
export CONDA_DEFAULT_ENV="foo";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(anaconda-2.3.0/envs/foo) \${PS1:-}";
export CONDA_PREFIX="${TMP}/pyenv/versions/anaconda-2.3.0/envs/foo";
. "${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo/etc/conda/activate.d/activate.sh";
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
teardown_conda "anaconda-2.3.0" "foo"
}
@test "activate conda env from command-line argument" {
export PYENV_VIRTUALENV_INIT=1
setup_conda "anaconda-2.3.0" "foo"
setup_conda "miniconda-3.9.1" "bar"
stub pyenv-virtualenv-prefix "miniconda-3.9.1/envs/bar : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1\""
stub pyenv-prefix "miniconda-3.9.1/envs/bar : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar\""
stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0/envs/foo" run pyenv-sh-activate "miniconda-3.9.1/envs/bar"
assert_success
assert_output <<EOS
deactivated
export PYENV_VERSION="miniconda-3.9.1/envs/bar";
export PYENV_ACTIVATE_SHELL=1;
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar";
export CONDA_DEFAULT_ENV="bar";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(miniconda-3.9.1/envs/bar) \${PS1:-}";
export CONDA_PREFIX="${TMP}/pyenv/versions/miniconda-3.9.1/envs/bar";
. "${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar/etc/conda/activate.d/activate.sh";
EOS
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-sh-deactivate
teardown_conda "anaconda-2.3.0" "foo"
teardown_conda "miniconda-3.9.1" "bar"
}
================================================
FILE: test/conda-deactivate.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
unset PYENV_VERSION
unset PYENV_ACTIVATE_SHELL
unset PYENV_VIRTUAL_ENV
unset VIRTUAL_ENV
unset CONDA_DEFAULT_ENV
unset PYTHONHOME
unset _OLD_VIRTUAL_PYTHONHOME
unset PYENV_VIRTUALENV_VERBOSE_ACTIVATE
unset PYENV_VIRTUALENV_DISABLE_PROMPT
unset PYENV_VIRTUAL_ENV_DISABLE_PROMPT
unset VIRTUAL_ENV_DISABLE_PROMPT
unset _OLD_VIRTUAL_PS1
stub pyenv-hooks "deactivate : echo"
}
teardown() {
unstub pyenv-hooks
}
@test "deactivate conda root" {
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0"
export PYENV_ACTIVATE_SHELL=
export CONDA_DEFAULT_ENV="root"
setup_conda "anaconda-2.3.0"
PYENV_SHELL="bash" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
unset CONDA_PREFIX
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
unset CONDA_DEFAULT_ENV;
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
EOS
teardown_conda "anaconda-2.3.0"
}
@test "deactivate conda root (fish)" {
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0"
export PYENV_ACTIVATE_SHELL=
export CONDA_DEFAULT_ENV="root"
setup_conda "anaconda-2.3.0"
PYENV_SHELL="fish" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
set -e PYENV_VIRTUAL_ENV;
set -e VIRTUAL_ENV;
set -e CONDA_DEFAULT_ENV;
if [ -n "\$_OLD_VIRTUAL_PATH" ];
set -gx PATH "\$_OLD_VIRTUAL_PATH";
set -e _OLD_VIRTUAL_PATH;
end;
if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
set -e _OLD_VIRTUAL_PYTHONHOME;
end;
# check if old prompt function exists
if functions -q _pyenv_old_prompt
# remove old prompt function if exists.
functions -e fish_prompt
functions -c _pyenv_old_prompt fish_prompt
functions -e _pyenv_old_prompt
end
if functions -q deactivate;
functions -e deactivate;
end;
EOS
teardown_conda "anaconda-2.3.0"
}
@test "deactivate conda env" {
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo"
export PYENV_ACTIVATE_SHELL=
export CONDA_DEFAULT_ENV="foo"
setup_conda "anaconda-2.3.0" "foo"
PYENV_SHELL="bash" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
. "${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo/etc/conda/deactivate.d/deactivate.sh";
unset CONDA_PREFIX
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
unset CONDA_DEFAULT_ENV;
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
EOS
teardown_conda "anaconda-2.3.0" "foo"
}
================================================
FILE: test/conda-prefix.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
}
@test "display conda root" {
setup_conda "anaconda-2.3.0"
stub pyenv-version-name "echo anaconda-2.3.0"
stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
PYENV_VERSION="anaconda-2.3.0" run pyenv-virtualenv-prefix
assert_success
assert_output <<OUT
${PYENV_ROOT}/versions/anaconda-2.3.0
OUT
unstub pyenv-version-name
unstub pyenv-prefix
teardown_conda "anaconda-2.3.0"
}
@test "display conda env" {
setup_conda "anaconda-2.3.0" "foo"
stub pyenv-version-name "echo anaconda-2.3.0/envs/foo"
stub pyenv-prefix "anaconda-2.3.0/envs/foo : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo\""
PYENV_VERSION="anaconda-2.3.0/envs/foo" run pyenv-virtualenv-prefix
assert_success
assert_output <<OUT
${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo
OUT
unstub pyenv-version-name
unstub pyenv-prefix
teardown_conda "anaconda-2.3.0" "foo"
}
================================================
FILE: test/conda.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
}
stub_pyenv() {
stub pyenv-version-name "echo \${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-hooks "virtualenv : echo"
stub pyenv-rehash " : echo rehashed"
}
unstub_pyenv() {
unstub pyenv-version-name
unstub pyenv-prefix
unstub pyenv-hooks
unstub pyenv-rehash
}
@test "create virtualenv by conda create" {
export PYENV_VERSION="miniconda3-3.16.0"
setup_conda "${PYENV_VERSION}"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub -N pyenv-exec "conda list * : true"
stub -N pyenv-exec "conda create * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : true"
run pyenv-virtualenv venv
assert_success
assert_output_wildcards <<OUT
PYENV_VERSION=miniconda3-3.16.0 conda create --name venv --yes --file /dev/fd/*
rehashed
OUT
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "miniconda3-3.16.0"
}
@test "create virtualenv by conda create with -p" {
export PYENV_VERSION="miniconda3-3.16.0"
setup_conda "${PYENV_VERSION}"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-exec "conda create * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : true"
run pyenv-virtualenv -p python3.5 venv
assert_success
assert_output <<OUT
PYENV_VERSION=miniconda3-3.16.0 conda create --name venv --yes python=3.5
rehashed
OUT
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "miniconda3-3.16.0"
}
@test "create virtualenv by conda create with --python" {
export PYENV_VERSION="miniconda3-3.16.0"
setup_conda "${PYENV_VERSION}"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-exec "conda create * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : true"
run pyenv-virtualenv --python=python3.5 venv
assert_success
assert_output <<OUT
PYENV_VERSION=miniconda3-3.16.0 conda create --name venv --yes python=3.5
rehashed
OUT
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "miniconda3-3.16.0"
}
================================================
FILE: test/deactivate.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
unset PYENV_VERSION
unset PYENV_ACTIVATE_SHELL
unset PYENV_VIRTUAL_ENV
unset VIRTUAL_ENV
unset CONDA_DEFAULT_ENV
unset PYTHONHOME
unset _OLD_VIRTUAL_PYTHONHOME
unset PYENV_VIRTUALENV_VERBOSE_ACTIVATE
unset PYENV_VIRTUALENV_DISABLE_PROMPT
unset PYENV_VIRTUAL_ENV_DISABLE_PROMPT
unset VIRTUAL_ENV_DISABLE_PROMPT
unset _OLD_VIRTUAL_PS1
stub pyenv-hooks "deactivate : echo"
}
@test "deactivate virtualenv" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=
PYENV_SHELL="bash" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
EOS
}
@test "deactivate virtualenv (quiet)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=
PYENV_SHELL="bash" run pyenv-sh-deactivate --quiet
assert_success
assert_output <<EOS
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
EOS
}
@test "deactivate virtualenv (verbose)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=
export PYENV_VIRTUALENV_VERBOSE_ACTIVATE=1
PYENV_SHELL="bash" run pyenv-sh-deactivate --verbose
assert_success
assert_output <<EOS
pyenv-virtualenv: deactivate venv
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
EOS
}
@test "deactivate virtualenv (with shell activation)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=1
PYENV_SHELL="bash" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
unset PYENV_VERSION;
unset PYENV_ACTIVATE_SHELL;
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
EOS
}
@test "deactivate virtualenv (with shell activation) (quiet)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=1
PYENV_SHELL="bash" run pyenv-sh-deactivate --quiet
assert_success
assert_output <<EOS
unset PYENV_VERSION;
unset PYENV_ACTIVATE_SHELL;
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
EOS
}
@test "deactivate virtualenv which has been activated manually" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=
PYENV_SHELL="bash" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
EOS
}
@test "deactivate virtualenv (fish)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=
PYENV_SHELL="fish" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
set -e PYENV_VIRTUAL_ENV;
set -e VIRTUAL_ENV;
if [ -n "\$_OLD_VIRTUAL_PATH" ];
set -gx PATH "\$_OLD_VIRTUAL_PATH";
set -e _OLD_VIRTUAL_PATH;
end;
if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
set -e _OLD_VIRTUAL_PYTHONHOME;
end;
# check if old prompt function exists
if functions -q _pyenv_old_prompt
# remove old prompt function if exists.
functions -e fish_prompt
functions -c _pyenv_old_prompt fish_prompt
functions -e _pyenv_old_prompt
end
if functions -q deactivate;
functions -e deactivate;
end;
EOS
}
@test "deactivate virtualenv (fish) (quiet)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=
PYENV_SHELL="fish" run pyenv-sh-deactivate --quiet
assert_success
assert_output <<EOS
set -e PYENV_VIRTUAL_ENV;
set -e VIRTUAL_ENV;
if [ -n "\$_OLD_VIRTUAL_PATH" ];
set -gx PATH "\$_OLD_VIRTUAL_PATH";
set -e _OLD_VIRTUAL_PATH;
end;
if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
set -e _OLD_VIRTUAL_PYTHONHOME;
end;
# check if old prompt function exists
if functions -q _pyenv_old_prompt
# remove old prompt function if exists.
functions -e fish_prompt
functions -c _pyenv_old_prompt fish_prompt
functions -e _pyenv_old_prompt
end
if functions -q deactivate;
functions -e deactivate;
end;
EOS
}
@test "deactivate virtualenv (fish) (with shell activation)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=1
PYENV_SHELL="fish" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
set -e PYENV_VERSION;
set -e PYENV_ACTIVATE_SHELL;
set -e PYENV_VIRTUAL_ENV;
set -e VIRTUAL_ENV;
if [ -n "\$_OLD_VIRTUAL_PATH" ];
set -gx PATH "\$_OLD_VIRTUAL_PATH";
set -e _OLD_VIRTUAL_PATH;
end;
if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
set -e _OLD_VIRTUAL_PYTHONHOME;
end;
# check if old prompt function exists
if functions -q _pyenv_old_prompt
# remove old prompt function if exists.
functions -e fish_prompt
functions -c _pyenv_old_prompt fish_prompt
functions -e _pyenv_old_prompt
end
if functions -q deactivate;
functions -e deactivate;
end;
EOS
}
@test "deactivate virtualenv (fish) (with shell activation) (quiet)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=1
PYENV_SHELL="fish" run pyenv-sh-deactivate --quiet
assert_success
assert_output <<EOS
set -e PYENV_VERSION;
set -e PYENV_ACTIVATE_SHELL;
set -e PYENV_VIRTUAL_ENV;
set -e VIRTUAL_ENV;
if [ -n "\$_OLD_VIRTUAL_PATH" ];
set -gx PATH "\$_OLD_VIRTUAL_PATH";
set -e _OLD_VIRTUAL_PATH;
end;
if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
set -e _OLD_VIRTUAL_PYTHONHOME;
end;
# check if old prompt function exists
if functions -q _pyenv_old_prompt
# remove old prompt function if exists.
functions -e fish_prompt
functions -c _pyenv_old_prompt fish_prompt
functions -e _pyenv_old_prompt
end
if functions -q deactivate;
functions -e deactivate;
end;
EOS
}
@test "deactivate virtualenv which has been activated manually (fish)" {
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=
PYENV_SHELL="fish" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
set -e PYENV_VIRTUAL_ENV;
set -e VIRTUAL_ENV;
if [ -n "\$_OLD_VIRTUAL_PATH" ];
set -gx PATH "\$_OLD_VIRTUAL_PATH";
set -e _OLD_VIRTUAL_PATH;
end;
if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
set -e _OLD_VIRTUAL_PYTHONHOME;
end;
# check if old prompt function exists
if functions -q _pyenv_old_prompt
# remove old prompt function if exists.
functions -e fish_prompt
functions -c _pyenv_old_prompt fish_prompt
functions -e _pyenv_old_prompt
end
if functions -q deactivate;
functions -e deactivate;
end;
EOS
}
@test "should fail if deactivate is invoked as a command" {
run pyenv-deactivate
assert_failure
}
================================================
FILE: test/delete.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
}
@test "delete virtualenv" {
mkdir -p "${PYENV_ROOT}/versions/venv27"
stub pyenv-virtualenv-prefix "venv27 : true"
stub pyenv-rehash "true"
run pyenv-virtualenv-delete -f "venv27"
assert_success
unstub pyenv-virtualenv-prefix
unstub pyenv-rehash
[ ! -d "${PYENV_ROOT}/versions/venv27" ]
}
@test "delete virtualenv by symlink" {
mkdir -p "${PYENV_ROOT}/versions/2.7.11/envs/venv27"
ln -fs "${PYENV_ROOT}/versions/2.7.11/envs/venv27" "${PYENV_ROOT}/versions/venv27"
stub pyenv-rehash "true"
run pyenv-virtualenv-delete -f "venv27"
assert_success
unstub pyenv-rehash
[ ! -d "${PYENV_ROOT}/versions/2.7.11/envs/venv27" ]
[ ! -L "${PYENV_ROOT}/versions/venv27" ]
}
@test "delete virtualenv with symlink" {
mkdir -p "${PYENV_ROOT}/versions/2.7.11/envs/venv27"
ln -fs "${PYENV_ROOT}/versions/2.7.11/envs/venv27" "${PYENV_ROOT}/versions/venv27"
stub pyenv-rehash "true"
run pyenv-virtualenv-delete -f "2.7.11/envs/venv27"
assert_success
unstub pyenv-rehash
[ ! -d "${PYENV_ROOT}/versions/2.7.11/envs/venv27" ]
[ ! -L "${PYENV_ROOT}/versions/venv27" ]
}
@test "not delete virtualenv with different symlink" {
mkdir -p "${PYENV_ROOT}/versions/2.7.8/envs/venv27"
mkdir -p "${PYENV_ROOT}/versions/2.7.11/envs/venv27"
ln -fs "${PYENV_ROOT}/versions/2.7.8/envs/venv27" "${PYENV_ROOT}/versions/venv27"
stub pyenv-rehash "true"
run pyenv-virtualenv-delete -f "2.7.11/envs/venv27"
assert_success
unstub pyenv-rehash
[ ! -d "${PYENV_ROOT}/versions/2.7.11/envs/venv27" ]
[ -L "${PYENV_ROOT}/versions/venv27" ]
}
@test "not delete virtualenv with same name" {
mkdir -p "${PYENV_ROOT}/versions/2.7.11/envs/venv27"
mkdir -p "${PYENV_ROOT}/versions/venv27"
stub pyenv-rehash "true"
run pyenv-virtualenv-delete -f "2.7.11/envs/venv27"
assert_success
unstub pyenv-rehash
[ ! -d "${PYENV_ROOT}/versions/2.7.11/envs/venv27" ]
[ -d "${PYENV_ROOT}/versions/venv27" ]
}
================================================
FILE: test/envs.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/envs/pyenv"
}
stub_pyenv() {
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-hooks "virtualenv : echo"
stub pyenv-rehash " : echo rehashed"
}
unstub_pyenv() {
unstub pyenv-prefix
unstub pyenv-hooks
unstub pyenv-rehash
}
@test "path should be handled properly even if there is 'envs' in PYENV_ROOT" {
export PYENV_VERSION="3.5.1"
setup_m_venv "3.5.1"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-version-name "echo '${PYENV_VERSION}'"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : true"
stub pyenv-exec "python -m venv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/3.5.1/envs/venv/bin"
stub pyenv-exec "python -s -m ensurepip : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pip"
run pyenv-virtualenv venv
assert_success
assert_output <<OUT
PYENV_VERSION=3.5.1 python -m venv ${PYENV_ROOT}/versions/3.5.1/envs/venv
PYENV_VERSION=3.5.1/envs/venv python -s -m ensurepip
rehashed
OUT
assert [ -e "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pip" ]
unstub_pyenv
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "3.5.1"
}
================================================
FILE: test/hooks.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
export HOOK_PATH="${TMP}/i has hooks"
mkdir -p "$HOOK_PATH"
unset PYENV_VIRTUALENV_PROMPT
}
@test "pyenv-virtualenv hooks" {
cat > "${HOOK_PATH}/virtualenv.bash" <<OUT
before_virtualenv 'echo before: \$VIRTUALENV_PATH'
after_virtualenv 'echo after: \$STATUS'
OUT
setup_version "3.5.1"
create_executable "3.5.1" "virtualenv"
stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.5.1'"
stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.5.1'"
stub pyenv-exec "python -m venv --help : true"
stub pyenv-hooks "virtualenv : echo '$HOOK_PATH'/virtualenv.bash"
stub pyenv-exec "echo PYENV_VERSION=3.5.1 \"\$@\""
stub pyenv-exec "echo PYENV_VERSION=3.5.1 \"\$@\""
stub pyenv-rehash "echo rehashed"
run pyenv-virtualenv "3.5.1" venv
assert_success
assert_output <<-OUT
before: ${PYENV_ROOT}/versions/3.5.1/envs/venv
PYENV_VERSION=3.5.1 virtualenv ${PYENV_ROOT}/versions/3.5.1/envs/venv
PYENV_VERSION=3.5.1 python -s -m ensurepip
after: 0
rehashed
OUT
unstub pyenv-prefix
unstub pyenv-hooks
unstub pyenv-exec
unstub pyenv-rehash
teardown_version "3.5.1"
}
@test "pyenv-sh-activate hooks" {
cat > "${HOOK_PATH}/activate.bash" <<OUT
before_activate 'echo "before"'
after_activate 'echo "after"'
OUT
export PYENV_VIRTUALENV_INIT=1
stub pyenv-version-name "echo venv"
stub pyenv-virtualenv-prefix ""
stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
stub pyenv-hooks "activate : echo '$HOOK_PATH'/activate.bash"
stub pyenv-sh-deactivate ""
PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate
assert_success
assert_output <<EOS
before
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
export _OLD_VIRTUAL_PS1="\${PS1:-}";
export PS1="(venv) \${PS1:-}";
after
EOS
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-prefix
unstub pyenv-hooks
unstub pyenv-sh-deactivate
}
@test "deactivate virtualenv" {
cat > "${HOOK_PATH}/deactivate.bash" <<OUT
before_deactivate 'echo "before"'
after_deactivate 'echo "after"'
OUT
export PYENV_VIRTUALENV_INIT=1
export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
export PYENV_ACTIVATE_SHELL=
stub pyenv-hooks "deactivate : echo '$HOOK_PATH'/deactivate.bash"
PYENV_SHELL="bash" run pyenv-sh-deactivate
assert_success
assert_output <<EOS
before
unset PYENV_VIRTUAL_ENV;
unset VIRTUAL_ENV;
if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
export PATH="\${_OLD_VIRTUAL_PATH}";
unset _OLD_VIRTUAL_PATH;
fi;
if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
unset _OLD_VIRTUAL_PYTHONHOME;
fi;
if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
export PS1="\${_OLD_VIRTUAL_PS1}";
unset _OLD_VIRTUAL_PS1;
fi;
if declare -f deactivate 1>/dev/null 2>&1; then
unset -f deactivate;
fi;
after
EOS
unstub pyenv-hooks
}
================================================
FILE: test/init.bats
================================================
#!/usr/bin/env bats
load test_helper
@test "detect parent shell" {
unset PYENV_SHELL
SHELL=/bin/false run pyenv-virtualenv-init -
assert_success
assert_output_contains ' PROMPT_COMMAND="_pyenv_virtualenv_hook;${PROMPT_COMMAND-}"'
}
@test "detect parent shell from script (sh)" {
unset PYENV_SHELL
printf '#!/bin/sh\necho "$(pyenv-virtualenv-init -)"' > "${TMP}/script.sh"
chmod +x ${TMP}/script.sh
run ${TMP}/script.sh
assert_success
assert_output_contains_not ' PROMPT_COMMAND="_pyenv_virtualenv_hook;${PROMPT_COMMAND-}"'
rm -f "${TMP}/script.sh"
}
@test "detect parent shell from script (bash)" {
unset PYENV_SHELL
printf '#!/bin/bash\necho "$(pyenv-virtualenv-init -)"' > "${TMP}/script.sh"
chmod +x ${TMP}/script.sh
run ${TMP}/script.sh
assert_success
assert_output_contains ' PROMPT_COMMAND="_pyenv_virtualenv_hook;${PROMPT_COMMAND-}"'
rm -f "${TMP}/script.sh"
}
@test "sh-compatible instructions" {
run pyenv-virtualenv-init bash
assert [ "$status" -eq 1 ]
assert_output_contains 'eval "$(pyenv virtualenv-init -)"'
run pyenv-virtualenv-init zsh
assert [ "$status" -eq 1 ]
assert_output_contains 'eval "$(pyenv virtualenv-init -)"'
}
@test "fish instructions" {
run pyenv-virtualenv-init fish
assert [ "$status" -eq 1 ]
assert_output_contains 'status --is-interactive; and source (pyenv virtualenv-init -|psub)'
}
@test "outputs bash-specific syntax" {
export PYENV_VIRTUALENV_ROOT="${TMP}/pyenv/plugins/pyenv-virtualenv"
run pyenv-virtualenv-init - bash
assert_success
assert_output <<EOS
export PATH="${TMP}/pyenv/plugins/pyenv-virtualenv/shims:\${PATH}";
export PYENV_VIRTUALENV_INIT=1;
_pyenv_virtualenv_hook() {
local ret=\$?
if [ -n "\${VIRTUAL_ENV-}" ]; then
eval "\$(pyenv sh-activate --quiet || pyenv sh-deactivate --quiet || true)" || true
else
eval "\$(pyenv sh-activate --quiet || true)" || true
fi
return \$ret
};
if ! [[ "\${PROMPT_COMMAND-}" =~ _pyenv_virtualenv_hook ]]; then
PROMPT_COMMAND="_pyenv_virtualenv_hook;\${PROMPT_COMMAND-}"
fi
EOS
}
@test "outputs fish-specific syntax" {
export PYENV_VIRTUALENV_ROOT="${TMP}/pyenv/plugins/pyenv-virtualenv"
run pyenv-virtualenv-init - fish
assert_success
assert_output <<EOS
while set index (contains -i -- "${TMP}/pyenv/plugins/pyenv-virtualenv/shims" \$PATH)
set -eg PATH[\$index]; end; set -e index
set -gx PATH '${TMP}/pyenv/plugins/pyenv-virtualenv/shims' \$PATH;
set -gx PYENV_VIRTUALENV_INIT 1;
function _pyenv_virtualenv_hook --on-event fish_prompt;
set -l ret \$status
if [ -n "\$VIRTUAL_ENV" ]
pyenv activate --quiet; or pyenv deactivate --quiet; or true
else
pyenv activate --quiet; or true
end
return \$ret
end
EOS
}
@test "outputs zsh-specific syntax" {
export PYENV_VIRTUALENV_ROOT="${TMP}/pyenv/plugins/pyenv-virtualenv"
run pyenv-virtualenv-init - zsh
assert_success
assert_output <<EOS
export PATH="${TMP}/pyenv/plugins/pyenv-virtualenv/shims:\${PATH}";
export PYENV_VIRTUALENV_INIT=1;
_pyenv_virtualenv_hook() {
local ret=\$?
if [ -n "\${VIRTUAL_ENV-}" ]; then
eval "\$(pyenv sh-activate --quiet || pyenv sh-deactivate --quiet || true)" || true
else
eval "\$(pyenv sh-activate --quiet || true)" || true
fi
return \$ret
};
typeset -g -a precmd_functions
if [[ -z \$precmd_functions[(r)_pyenv_virtualenv_hook] ]]; then
precmd_functions=(_pyenv_virtualenv_hook \$precmd_functions);
fi
EOS
}
================================================
FILE: test/installer.bats
================================================
#!/usr/bin/env bats
load test_helper
@test "installs pyenv-virtualenv into PREFIX" {
cd "$TMP"
PREFIX="${PWD}/usr" run "${BATS_TEST_DIRNAME}/../install.sh"
assert_success ""
cd usr
assert [ -x bin/pyenv-activate ]
assert [ -x bin/pyenv-deactivate ]
assert [ -x bin/pyenv-sh-activate ]
assert [ -x bin/pyenv-sh-deactivate ]
assert [ -x bin/pyenv-virtualenv ]
assert [ -x bin/pyenv-virtualenv-init ]
assert [ -x bin/pyenv-virtualenv-prefix ]
assert [ -x bin/pyenv-virtualenvs ]
}
@test "overwrites old installation" {
cd "$TMP"
mkdir -p bin
touch bin/pyenv-virtualenv
PREFIX="$PWD" run "${BATS_TEST_DIRNAME}/../install.sh"
assert_success ""
assert [ -x bin/pyenv-virtualenv ]
run grep "virtualenv" bin/pyenv-virtualenv
assert_success
}
@test "unrelated files are untouched" {
cd "$TMP"
mkdir -p bin share/bananas
chmod g-w bin
touch bin/bananas
PREFIX="$PWD" run "${BATS_TEST_DIRNAME}/../install.sh"
assert_success ""
assert [ -e bin/bananas ]
run ls -ld bin
assert_equal "r-x" "${output:4:3}"
}
================================================
FILE: test/pip.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
}
stub_pyenv() {
stub pyenv-version-name "echo \${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-hooks "virtualenv : echo"
stub pyenv-rehash " : echo rehashed"
}
unstub_pyenv() {
unstub pyenv-version-name
unstub pyenv-prefix
unstub pyenv-hooks
unstub pyenv-rehash
}
@test "install pip with ensurepip" {
export PYENV_VERSION="3.5.1"
setup_m_venv "3.5.1"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : true"
stub pyenv-exec "python -m venv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/3.5.1/envs/venv/bin"
stub pyenv-exec "python -s -m ensurepip : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pip"
run pyenv-virtualenv venv
assert_success
assert_output <<OUT
PYENV_VERSION=3.5.1 python -m venv ${TMP}/pyenv/versions/3.5.1/envs/venv
PYENV_VERSION=3.5.1/envs/venv python -s -m ensurepip
rehashed
OUT
assert [ -e "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pip" ]
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "3.5.1"
}
@test "install pip without using ensurepip" {
export PYENV_VERSION="3.3.6"
setup_m_venv "3.3.6"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : true"
stub pyenv-exec "python -m venv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/3.3.6/envs/venv/bin"
stub pyenv-exec "python -s -m ensurepip : false"
stub pyenv-exec "python -s */get-pip.py : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/3.3.6/envs/venv/bin/pip"
stub curl true
run pyenv-virtualenv venv
assert_success
assert_output <<OUT
PYENV_VERSION=3.3.6 python -m venv ${PYENV_ROOT}/versions/3.3.6/envs/venv
Installing pip from https://bootstrap.pypa.io/pip/3.3/get-pip.py...
PYENV_VERSION=3.3.6/envs/venv python -s ${TMP}/pyenv/cache/get-pip.py
rehashed
OUT
assert [ -e "${PYENV_ROOT}/versions/3.3.6/envs/venv/bin/pip" ]
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "3.3.6"
}
================================================
FILE: test/prefix.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
}
create_version() {
mkdir -p "${PYENV_ROOT}/versions/$1/bin"
touch "${PYENV_ROOT}/versions/$1/bin/python"
chmod +x "${PYENV_ROOT}/versions/$1/bin/python"
}
remove_version() {
rm -fr "${PYENV_ROOT}/versions/$1"
}
create_virtualenv() {
create_version "$1"
create_version "${2:-$1}"
mkdir -p "${PYENV_ROOT}/versions/$1/lib/python${2:-$1}"
echo "${PYENV_ROOT}/versions/${2:-$1}" > "${PYENV_ROOT}/versions/$1/lib/python${2:-$1}/orig-prefix.txt"
touch "${PYENV_ROOT}/versions/$1/bin/activate"
}
create_virtualenv_jython() {
create_version "$1"
create_version "${2:-$1}"
mkdir -p "${PYENV_ROOT}/versions/$1/Lib/"
echo "${PYENV_ROOT}/versions/${2:-$1}" > "${PYENV_ROOT}/versions/$1/Lib/orig-prefix.txt"
touch "${PYENV_ROOT}/versions/$1/bin/activate"
}
create_virtualenv_pypy() {
create_version "$1"
create_version "${2:-$1}"
mkdir -p "${PYENV_ROOT}/versions/$1/lib-python/${2:-$1}"
echo "${PYENV_ROOT}/versions/${2:-$1}" > "${PYENV_ROOT}/versions/$1/lib-python/${2:-$1}/orig-prefix.txt"
touch "${PYENV_ROOT}/versions/$1/bin/activate"
}
remove_virtualenv() {
remove_version "$1"
remove_version "${2:-$1}"
}
create_m_venv() {
create_version "$1"
create_version "${2:-$1}"
echo "home = ${PYENV_ROOT}/versions/${2:-$1}/bin" > "${PYENV_ROOT}/versions/$1/pyvenv.cfg"
touch "${PYENV_ROOT}/versions/$1/bin/activate"
}
remove_m_venv() {
remove_version "${2:-$1}"
}
create_conda() {
create_version "$1"
create_version "${2:-$1}"
touch "${PYENV_ROOT}/versions/$1/bin/conda"
touch "${PYENV_ROOT}/versions/$1/bin/activate"
mkdir -p "${PYENV_ROOT}/versions/${2:-$1}/bin"
touch "${PYENV_ROOT}/versions/${2:-$1}/bin/conda"
touch "${PYENV_ROOT}/versions/${2:-$1}/bin/activate"
}
remove_conda() {
remove_version "${2:-$1}"
}
@test "display prefix of virtualenv created by virtualenv" {
stub pyenv-version-name "echo foo"
stub pyenv-prefix "foo : echo \"${PYENV_ROOT}/versions/foo\""
create_virtualenv "foo" "2.7.11"
PYENV_VERSION="foo" run pyenv-virtualenv-prefix
assert_success
assert_output <<OUT
${PYENV_ROOT}/versions/2.7.11
OUT
unstub pyenv-version-name
unstub pyenv-prefix
remove_virtualenv "foo" "2.7.11"
}
@test "display prefix of virtualenv created by virtualenv (pypy)" {
stub pyenv-version-name "echo foo"
stub pyenv-prefix "foo : echo \"${PYENV_ROOT}/versions/foo\""
create_virtualenv_pypy "foo" "pypy-4.0.1"
PYENV_VERSION="foo" run pyenv-virtualenv-prefix
assert_success
assert_output <<OUT
${PYENV_ROOT}/versions/pypy-4.0.1
OUT
unstub pyenv-version-name
unstub pyenv-prefix
remove_virtualenv "foo" "pypy-4.0.1"
}
@test "display prefix of virtualenv created by virtualenv (jython)" {
stub pyenv-version-name "echo foo"
stub pyenv-prefix "foo : echo \"${PYENV_ROOT}/versions/foo\""
create_virtualenv_jython "foo" "jython-2.7.0"
PYENV_VERSION="foo" run pyenv-virtualenv-prefix
assert_success
assert_output <<OUT
${PYENV_ROOT}/versions/jython-2.7.0
OUT
unstub pyenv-version-name
unstub pyenv-prefix
remove_virtualenv "foo" "jython-2.7.0"
}
@test "display prefixes of virtualenv created by virtualenv" {
stub pyenv-version-name "echo foo:bar"
stub pyenv-prefix "foo : echo \"${PYENV_ROOT}/versions/foo\"" \
"bar : echo \"${PYENV_ROOT}/versions/bar\""
create_virtualenv "foo" "2.7.11"
create_virtualenv "bar" "3.5.1"
PYENV_VERSION="foo:bar" run pyenv-virtualenv-prefix
assert_success
assert_output <<OUT
${PYENV_ROOT}/versions/2.7.11:${PYENV_ROOT}/versions/3.5.1
OUT
unstub pyenv-version-name
unstub pyenv-prefix
remove_virtualenv "foo" "2.7.11"
remove_virtualenv "bar" "3.5.1"
}
@test "display prefix of virtualenv created by venv" {
stub pyenv-version-name "echo foo"
stub pyenv-prefix "foo : echo \"${PYENV_ROOT}/versions/foo\""
create_m_venv "foo" "3.3.6"
PYENV_VERSION="foo" run pyenv-virtualenv-prefix
assert_success
assert_output <<OUT
${PYENV_ROOT}/versions/3.3.6
OUT
unstub pyenv-version-name
unstub pyenv-prefix
remove_m_venv "foo" "3.3.6"
}
@test "display prefixes of virtualenv created by venv" {
stub pyenv-version-name "echo foo:bar"
stub pyenv-prefix "foo : echo \"${PYENV_ROOT}/versions/foo\"" \
"bar : echo \"${PYENV_ROOT}/versions/bar\""
create_m_venv "foo" "3.3.6"
create_m_venv "bar" "3.4.4"
PYENV_VERSION="foo:bar" run pyenv-virtualenv-prefix
assert_success
assert_output <<OUT
${PYENV_ROOT}/versions/3.3.6:${PYENV_ROOT}/versions/3.4.4
OUT
unstub pyenv-version-name
unstub pyenv-prefix
remove_m_venv "foo" "3.3.6"
remove_m_venv "bar" "3.4.4"
}
@test "display prefix of virtualenv created by conda" {
stub pyenv-version-name "echo miniconda3-3.16.0/envs/foo"
stub pyenv-prefix "miniconda3-3.16.0/envs/foo : echo \"${PYENV_ROOT}/versions/miniconda3-3.16.0/envs/foo\""
create_conda "miniconda3-3.16.0/envs/foo" "miniconda3-3.16.0"
PYENV_VERSION="miniconda3-3.16.0/envs/foo" run pyenv-virtualenv-prefix
assert_success
assert_output <<OUT
${PYENV_ROOT}/versions/miniconda3-3.16.0/envs/foo
OUT
unstub pyenv-version-name
unstub pyenv-prefix
remove_conda "miniconda3-3.16.0/envs/foo" "miniconda3-3.16.0"
}
@test "should fail if the version is the system" {
stub pyenv-version-name "echo system"
PYENV_VERSION="system" run pyenv-virtualenv-prefix
assert_failure
assert_output <<OUT
pyenv-virtualenv: version \`system' is not a virtualenv
OUT
unstub pyenv-version-name
}
@test "should fail if the version is not a virtualenv" {
stub pyenv-version-name "echo 3.4.4"
stub pyenv-prefix "3.4.4 : echo \"${PYENV_ROOT}/versions/3.4.4\""
create_version "3.4.4"
PYENV_VERSION="3.4.4" run pyenv-virtualenv-prefix
assert_failure
assert_output <<OUT
pyenv-virtualenv: version \`3.4.4' is not a virtualenv
OUT
unstub pyenv-version-name
unstub pyenv-prefix
remove_version "3.4.4"
}
@test "should fail if one of the versions is not a virtualenv" {
stub pyenv-version-name "echo venv33:3.4.4"
stub pyenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/venv33\"" \
"3.4.4 : echo \"${PYENV_ROOT}/versions/3.4.4\""
create_virtualenv "venv33" "3.3.6"
create_version "3.4.4"
PYENV_VERSION="venv33:3.4.4" run pyenv-virtualenv-prefix
assert_failure
assert_output <<OUT
pyenv-virtualenv: version \`3.4.4' is not a virtualenv
OUT
unstub pyenv-version-name
unstub pyenv-prefix
remove_virtualenv "venv33" "3.3.6"
remove_version "3.4.4"
}
================================================
FILE: test/python.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
export PYENV_VERSION="2.7.8"
setup_version "2.7.8"
create_executable "2.7.8" "virtualenv"
stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-hooks "virtualenv : echo"
stub pyenv-rehash " : true"
stub pyenv-version-name "echo \${PYENV_VERSION}"
stub curl true
stub python-build "echo python2.7"
}
teardown() {
unstub curl
unstub pyenv-version-name
unstub pyenv-prefix
unstub pyenv-hooks
unstub pyenv-rehash
unstub python-build
teardown_version "2.7.8"
rm -fr "$TMP"/*
}
@test "resolve python executable from enabled version" {
remove_executable "2.7.7" "python2.7"
create_executable "2.7.8" "python2.7"
remove_executable "2.7.9" "python2.7"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "virtualenv --verbose * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : true"
stub pyenv-which "python2.7 : echo ${PYENV_ROOT}/versions/2.7.8/bin/python2.7"
run pyenv-virtualenv --verbose --python=python2.7 venv
unstub pyenv-exec
assert_output <<OUT
PYENV_VERSION=2.7.8 virtualenv --verbose --python=${PYENV_ROOT}/versions/2.7.8/bin/python2.7 ${PYENV_ROOT}/versions/2.7.8/envs/venv
OUT
assert_success
unstub pyenv-which
remove_executable "2.7.7" "python2.7"
remove_executable "2.7.8" "python2.7"
remove_executable "2.7.9" "python2.7"
}
@test "resolve python executable from other versions" {
remove_executable "2.7.7" "python2.7"
remove_executable "2.7.8" "python2.7"
create_executable "2.7.9" "python2.7"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "virtualenv --verbose * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : true"
stub pyenv-which "python2.7 : false"
stub pyenv-whence "python2.7 : echo 2.7.7; echo 2.7.8; echo 2.7.9"
stub pyenv-which "python2.7 : echo ${PYENV_ROOT}/versions/2.7.9/bin/python2.7"
run pyenv-virtualenv --verbose --python=python2.7 venv
assert_output <<OUT
PYENV_VERSION=2.7.8 virtualenv --verbose --python=${PYENV_ROOT}/versions/2.7.9/bin/python2.7 ${PYENV_ROOT}/versions/2.7.8/envs/venv
OUT
assert_success
unstub pyenv-which
unstub pyenv-whence
unstub pyenv-exec
remove_executable "2.7.7" "python2.7"
remove_executable "2.7.8" "python2.7"
remove_executable "2.7.9" "python2.7"
}
@test "cannot resolve python executable" {
remove_executable "2.7.7" "python2.7"
remove_executable "2.7.8" "python2.7"
remove_executable "2.7.9" "python2.7"
stub pyenv-which "python2.7 : false"
stub pyenv-whence "python2.7 : false"
stub pyenv-which "python2.7 : false"
run pyenv-virtualenv --verbose --python=python2.7 venv
assert_output <<OUT
pyenv-virtualenv: \`python2.7' is not installed in pyenv.
Run \`pyenv install python2.7' to install it.
OUT
assert_failure
unstub pyenv-which
unstub pyenv-whence
remove_executable "2.7.7" "python2.7"
remove_executable "2.7.8" "python2.7"
remove_executable "2.7.9" "python2.7"
}
@test "invalid python name" {
run pyenv-virtualenv --verbose --python=99.99.99 venv
assert_output <<OUT
pyenv-virtualenv: \`99.99.99' is not installed in pyenv.
It does not look like a valid Python version. See \`pyenv install --list' for available versions.
OUT
assert_failure
}
================================================
FILE: test/pyvenv.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
}
stub_pyenv() {
stub pyenv-version-name "echo \${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-hooks "virtualenv : echo"
stub pyenv-rehash " : echo rehashed"
}
unstub_pyenv() {
unstub pyenv-version-name
unstub pyenv-prefix
unstub pyenv-hooks
unstub pyenv-rehash
}
@test "use venv if virtualenv is not available" {
export PYENV_VERSION="3.5.1"
setup_m_venv "3.5.1"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : true"
stub pyenv-exec "python -m venv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : true"
run pyenv-virtualenv venv
assert_output <<OUT
PYENV_VERSION=3.5.1 python -m venv ${PYENV_ROOT}/versions/3.5.1/envs/venv
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "3.5.1"
}
@test "not use venv if virtualenv is available" {
export PYENV_VERSION="3.5.1"
setup_m_venv "3.5.1"
create_executable "3.5.1" "virtualenv"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : true"
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : true"
run pyenv-virtualenv venv
assert_output <<OUT
PYENV_VERSION=3.5.1 virtualenv ${PYENV_ROOT}/versions/3.5.1/envs/venv
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "3.5.1"
}
@test "install virtualenv if venv is not available" {
export PYENV_VERSION="3.2.1"
setup_version "3.2.1"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "pip install virtualenv* : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
run pyenv-virtualenv venv
assert_output <<OUT
PYENV_VERSION=3.2.1 pip install virtualenv==13.1.2
PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/3.2.1/envs/venv
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/3.2.1/envs/venv/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_version "3.2.1"
}
@test "install virtualenv if -p has given" {
export PYENV_VERSION="3.5.1"
setup_m_venv "3.5.1"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : true"
stub pyenv-exec "pip install virtualenv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : true"
run pyenv-virtualenv -p ${TMP}/python3 venv
assert_output <<OUT
PYENV_VERSION=3.5.1 pip install virtualenv
PYENV_VERSION=3.5.1 virtualenv --python=${TMP}/python3 ${PYENV_ROOT}/versions/3.5.1/envs/venv
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "3.5.1"
}
@test "install virtualenv if --python has given" {
export PYENV_VERSION="3.5.1"
setup_m_venv "3.5.1"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : true"
stub pyenv-exec "pip install virtualenv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : true"
run pyenv-virtualenv --python=${TMP}/python3 venv
assert_output <<OUT
PYENV_VERSION=3.5.1 pip install virtualenv
PYENV_VERSION=3.5.1 virtualenv --python=${TMP}/python3 ${PYENV_ROOT}/versions/3.5.1/envs/venv
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_m_venv "3.5.1"
}
@test "install virtualenv with unsetting troublesome pip options" {
export PYENV_VERSION="3.2.1"
setup_version "3.2.1"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "pip install virtualenv* : echo PIP_REQUIRE_VENV=\${PIP_REQUIRE_VENV} PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "virtualenv * : echo PIP_REQUIRE_VENV=\${PIP_REQUIRE_VENV} PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
PIP_REQUIRE_VENV="true" run pyenv-virtualenv venv
assert_output <<OUT
PIP_REQUIRE_VENV= PYENV_VERSION=3.2.1 pip install virtualenv==13.1.2
PIP_REQUIRE_VENV= PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/3.2.1/envs/venv
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/3.2.1/envs/venv/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
teardown_version "3.2.1"
}
================================================
FILE: test/stubs/stub
================================================
#!/usr/bin/env bash
export PS4='+($$:${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
set -e
status=0
program="${0##*/}"
PROGRAM="$(echo "$program" | tr a-z- A-Z_)"
[ -n "$TMPDIR" ] || TMPDIR="/tmp"
STUB_PLAN="${PROGRAM}_STUB_PLAN"
STUB_PLAN="${!STUB_PLAN}"
STUB_RUN="${PROGRAM}_STUB_RUN"
STUB_RUN="${!STUB_RUN:-${TMPDIR}/${program}-stub-run}"
STUB_INDEX=
STUB_RESULT=
STUB_END="${PROGRAM}_STUB_END"
STUB_END="${!STUB_END}"
STUB_LOG="${PROGRAM}_STUB_LOG"
STUB_LOG="${!STUB_LOG:-${TMPDIR}/${program}-stub-log}"
STUB_LOCKFILE="${TMPDIR}/${program}-stub.lock"
release_lock() {
rm -f "$STUB_LOCKFILE"
trap - EXIT
}
acquire_lock() {
local start=$SECONDS
local acquire_timeout=10
local acquired=
while (( SECONDS <= start + $acquire_timeout )); do
( set -o noclobber; echo -n >"$STUB_LOCKFILE" ) 2>/dev/null && acquired=1
if [[ -n $acquired ]]; then
trap release_lock EXIT
break
else
# POSIX sleep(1) doesn't provide subsecond precision, but many others do
sleep 0.1 2>/dev/null || sleep 1
fi
done
if [[ -z $acquired ]]; then
echo "$0: error: could not acquire stub lock \`$STUB_LOCKFILE' in ${acquire_timeout} seconds" >&2
exit 2
fi
}
acquire_lock
if [[ -z $STUB_END ]]; then echo "$program" "$@" >>"$STUB_LOG"; fi
[[ -e $STUB_PLAN ]] || exit 1
# Initialize or load the stub run information.
read_runfile() {
if [[ -e $STUB_RUN ]]; then source "$STUB_RUN"; fi
}
write_runfile() {
{
local i
echo "STUB_INDEX=$STUB_INDEX"
echo "STUB_RESULT=$STUB_RESULT"
echo "STUB_RUNCOUNTS=()"
for i in ${!STUB_RUNCOUNTS[@]}; do
echo "STUB_RUNCOUNTS[$i]=${STUB_RUNCOUNTS[$i]}"
done
} > "$STUB_RUN"
}
update_runfile_index() {
( STUB_INDEX=$((STUB_INDEX + 1))
write_runfile
)
}
update_runfile_result() {
(
# Another stubs may have run while we were running payload
# So we need to merge possible state changes
local our_result="$STUB_RESULT"
local -a our_runcounts
array_copy STUB_RUNCOUNTS our_runcounts
read_runfile
# merge our match_result and their match_result, with failure taking precedence
STUB_RESULT=$(( our_result | STUB_RESULT ))
# 3-way merge STUB_RUNCOUNTS (their changes),
# our_runcounts (our changes) and initial_runcounts (base)
local i
for i in $(printf '%s\n' ${!STUB_RUNCOUNTS[@]} ${!our_runcounts[@]} | sort -u); do
STUB_RUNCOUNTS[$i]=$((STUB_RUNCOUNTS[i] + our_runcounts[i] - initial_runcounts[i]))
done
write_runfile
)
}
array_copy() {
#`declare -p' is supposed to produce "declare -a src=([index]="value" <etc>)"
local data="$(declare -p ${1:?})"
local dest="${2:?}"
# Bash 5 dumps empty arrays as "declare -a arr"
if [[ $data != *=* ]]; then
data="()";
else
data="${data#*=}"
fi
# Bash 3 and MacPorts version of Bash 5 dump arrays in single quotes "declare -a arr='()'"
# but arr='(<value>)' createss "([0]='<value>')" rather than duplicate the array
if [[ ${data:0:1} == "'" && ${data:${#data}-1:1} == "'" ]]; then
data="${data:1:${#data}-2}"
fi
eval "$dest=$data"
}
STUB_INDEX=1
STUB_RESULT=0
declare -a STUB_RUNCOUNTS
read_runfile
declare -a initial_runcounts
array_copy STUB_RUNCOUNTS initial_runcounts
# ${PROGRAM}_STUB_END envvar is set externally to trigger verification mode for `unstub'
# Execution mode
if [[ -z $STUB_END ]]; then
# Loop over each line in the plan.
regular_command_index=0
no_order_command_index=0
match_result=1
while IFS= read -r line; do
line_flags="${line%% *}"
line="${line#${line_flags} }"
line_flag_no_order="$(if [[ $line_flags == N ]]; then echo 1; fi)"
line_flag_multiple="$(if [[ $line_flags == M ]]; then echo 1; fi)"
line_flag_regular="$(if [[ $line_flags == - ]]; then echo 1; fi)"
unset line_flags
# Go through the plan until a match is found.
# For regular commands, only check the next command by index.
# Also keep track of no-order commands for the purpose of run count tracking
if [[ -n $line_flag_regular ]]; then
regular_command_index=$(($regular_command_index + 1))
if [[ $regular_command_index -ne $STUB_INDEX ]]; then
continue;
fi
else
no_order_command_index=$(($no_order_command_index + 1))
fi
# Split the line into an array of arguments to
# match and a command to run to produce output.
command=" $line"
if [[ $command == *" : "* ]]; then
patterns="${command%% : *}"
command="${command#* : }"
fi
# Naively split patterns by whitespace for now.
# In the future, use a sed script to split while
# respecting quoting.
set -f
patterns=($patterns)
set +f
arguments=("$@")
# Match the expected argument patterns to actual
# arguments.
match_result=0
for (( i=0; i<${#patterns[@]}; i++ )); do
pattern="${patterns[$i]}"
argument="${arguments[$i]}"
case "$argument" in
$pattern ) ;;
* ) match_result=1 ;;
esac
done
# If the arguments matched, evaluate the command
# in a subshell. Otherwise, log the failure.
if [ $match_result -eq 0 ] ; then
# If this is a regular command, push the regular command index for the next stub invocation
if [[ -n $line_flag_regular ]]; then
update_runfile_index
else
STUB_RUNCOUNTS[$no_order_command_index]=$((STUB_RUNCOUNTS[no_order_command_index]+1))
fi
# Release the lock while running the payload to allow another `stub'
# of the same program to run concurrently (e.g. in a pipeline).
release_lock
( eval "$command" ) && status="$?" || status="$?"
break
fi
done < "$STUB_PLAN"
#If we never matched anything, we failed.
if [[ $match_result -eq 1 ]]; then
STUB_RESULT=1
#This also means that we never released the lock
# before running the payload
else
acquire_lock
fi
# Write out the match_result information.
update_runfile_result
release_lock
exit "$status"
fi
# Verification mode (`unstub')
if [[ -n $STUB_END ]]; then
# `unstub' is supposed to run after any stubs are finished
release_lock
# If the number of regular commands in the plan is larger than
# the final regular_command_index, we failed.
if [[ $(grep -Ee '^-' "$STUB_PLAN" | wc -l ) -ge $STUB_INDEX ]]; then
STUB_RESULT=1
fi
# If no-order commands weren't executed exactly once
# and multiple-times commands at least once, we failed.
no_order_command_index=0
while IFS= read -r line; do
line_flags="${line%% *}"
line="${line#${line_flags} }"
line_flag_no_order="$(if [[ $line_flags == N ]]; then echo 1; fi)"
line_flag_multiple="$(if [[ $line_flags == M ]]; then echo 1; fi)"
line_flag_regular="$(if [[ $line_flags == - ]]; then echo 1; fi)"
unset line_flags
if [[ -z $line_flag_regular ]]; then
continue
fi
no_order_command_index=$((no_order_command_index + 1))
if [[ ( -n $line_flag_no_order && \
(( STUB_RUNCOUNTS[no_order_command_index] != 1 )) ) \
|| \
( -n $line_flag_multiple && \
(( STUB_RUNCOUNTS[no_order_command_index] < 1 )) ) ]]
then
STUB_RESULT=1
fi
done < "$STUB_PLAN"
if [[ $STUB_RESULT -ne 0 ]]; then
{
echo "plan:"
cat "$STUB_PLAN" || true
echo "log:"
cat "$STUB_LOG" || true
} >&2
fi
# Clean up the run file.
rm -f "$STUB_RUN"
rm -f "$STUB_LOG"
# Return the run result.
exit "$STUB_RESULT"
fi
================================================
FILE: test/test_helper.bash
================================================
export TMP="$BATS_TEST_DIRNAME/tmp"
export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
PATH=/usr/bin:/usr/sbin:/bin:/sbin
PATH="$BATS_TEST_DIRNAME/../bin:$PATH"
PATH="$TMP/bin:$PATH"
export PATH
teardown() {
rm -fr "$TMP"/*
}
stub() {
local FLAG_NO_ORDER=
local FLAG_MULTIPLE=
while (($#)); do
case "$1" in
-N|--no-order)
FLAG_NO_ORDER=1
shift
;;
-M|--multiple)
FLAG_MULTIPLE=1
shift
;;
-*)
echo "stub: unrecognized switch: $arg" >$2
return 1
;;
*)
break
;;
esac
done
local FLAGS=-
if [[ -n $FLAG_MULTIPLE ]]; then
FLAGS=M
elif [[ -n $FLAG_NO_ORDER ]]; then
FLAGS=N
fi
local program="$1"
local prefix="$(echo "$program" | tr a-z- A-Z_)"
shift
export "${prefix}_STUB_PLAN"="${TMP}/${program}-stub-plan"
export "${prefix}_STUB_RUN"="${TMP}/${program}-stub-run"
export "${prefix}_STUB_LOG"="${TMP}/${program}-stub-log"
export "${prefix}_STUB_END"=
mkdir -p "${TMP}/bin"
ln -sf "${BATS_TEST_DIRNAME}/stubs/stub" "${TMP}/bin/${program}"
touch "${TMP}/${program}-stub-plan"
for arg in "$@"; do
echo "$FLAGS" "$arg" >> "${TMP}/${program}-stub-plan"
done
}
unstub() {
local program="$1"
local prefix="$(echo "$program" | tr a-z- A-Z_)"
local path="${TMP}/bin/${program}"
export "${prefix}_STUB_END"=1
local STATUS=0
"$path" || STATUS="$?"
rm -f "$path"
rm -f "${TMP}/${program}-stub-plan" "${TMP}/${program}-stub-run"
return "$STATUS"
}
assert() {
if ! "$@"; then
flunk "failed: $@"
fi
}
flunk() {
{ if [ "$#" -eq 0 ]; then cat -
else echo "$@"
fi
} | sed "s:${TMP}:\${TMP}:g" >&2
return 1
}
assert_success() {
if [ "$status" -ne 0 ]; then
{ echo "command failed with exit status $status"
echo "output: $output"
} | flunk
elif [ "$#" -gt 0 ]; then
assert_output "$1"
fi
}
assert_failure() {
if [ "$status" -eq 0 ]; then
flunk "expected failed exit status"
elif [ "$#" -gt 0 ]; then
assert_output "$1"
fi
}
assert_equal() {
if [ "$1" != "$2" ]; then
{ echo "expected:"
echo "$1"
echo "actual:"
echo "$2"
} | flunk
fi
}
assert_equal_wildcards() {
if [[ $1 != $2 ]]; then
{ echo "expected:"
echo "$2"
echo "actual:"
echo "$1"
} | flunk
fi
}
assert_output() {
local expected
if [ $# -eq 0 ]; then expected="$(cat -)"
else expected="$1"
fi
assert_equal "$expected" "$output"
}
assert_output_wildcards() {
local expected
if [ $# -eq 0 ]; then expected="$(cat -)"
else expected="$1"
fi
assert_equal_wildcards "$output" "$expected"
}
assert_output_contains() {
local expected="$1"
echo "$output" | grep -F "$expected" >/dev/null || {
{ echo "expected output to contain $expected"
echo "actual: $output"
} | flunk
}
}
assert_output_contains_not() {
local expected="$1"
echo "$output" | grep -F "$expected" >/dev/null && {
{ echo "expected output to not contain $expected"
echo "actual: $output"
} | flunk; return
}
return 0
}
create_executable() {
mkdir -p "${PYENV_ROOT}/versions/$1/bin"
touch "${PYENV_ROOT}/versions/$1/bin/$2"
chmod +x "${PYENV_ROOT}/versions/$1/bin/$2"
}
remove_executable() {
rm -f "${PYENV_ROOT}/versions/$1/bin/$2"
}
setup_version() {
create_executable "$1" "python"
remove_executable "$1" "activate"
remove_executable "$1" "conda"
}
teardown_version() {
rm -fr "${PYENV_ROOT}/versions/$1"
}
setup_virtualenv() {
create_executable "$1" "python"
create_executable "$1" "activate"
remove_executable "$1" "conda"
}
teardown_virtualenv() {
rm -fr "${PYENV_ROOT}/versions/$1"
}
setup_m_venv() {
create_executable "$1" "python"
create_executable "$1" "activate"
remove_executable "$1" "conda"
}
teardown_m_venv() {
rm -fr "${PYENV_ROOT}/versions/$1"
}
setup_conda() {
create_executable "$1" "python"
create_executable "$1" "activate"
create_executable "$1" "conda"
local conda="$1"
shift 1
local env
for env; do
create_executable "${conda}/envs/${env}" "python"
create_executable "${conda}/envs/${env}" "activate"
create_executable "${conda}/envs/${env}" "conda"
mkdir -p "${PYENV_ROOT}/versions/${conda}/envs/${env}/etc/conda/activate.d"
touch "${PYENV_ROOT}/versions/${conda}/envs/${env}/etc/conda/activate.d/activate.sh"
mkdir -p "${PYENV_ROOT}/versions/${conda}/envs/${env}/etc/conda/deactivate.d"
touch "${PYENV_ROOT}/versions/${conda}/envs/${env}/etc/conda/deactivate.d/deactivate.sh"
done
}
teardown_conda() {
rm -fr "${PYENV_ROOT}/versions/$1"
}
================================================
FILE: test/version.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
}
@test "display virtualenv version" {
setup_virtualenv "2.7.7"
stub pyenv-prefix "echo '${PYENV_ROOT}/versions/2.7.7'"
stub pyenv-version-name "echo 2.7.7"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "virtualenv --version : echo \"1.11\""
run pyenv-virtualenv --version
assert_success
[[ "$output" == "pyenv-virtualenv "?.?.?" (virtualenv 1.11)" ]]
unstub pyenv-prefix
unstub pyenv-exec
teardown_virtualenv "2.7.7"
}
@test "display venv version" {
setup_m_venv "3.4.1"
stub pyenv-version-name "echo 3.4.1"
stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.4.1'"
stub pyenv-exec "python -m venv --help : true"
run pyenv-virtualenv --version
assert_success
[[ "$output" == "pyenv-virtualenv "?.?.?" (python -m venv)" ]]
unstub pyenv-prefix
teardown_m_venv "3.4.1"
}
================================================
FILE: test/virtualenv.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
}
stub_pyenv() {
setup_version "${PYENV_VERSION}"
create_executable "${PYENV_VERSION}" "virtualenv"
stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
stub pyenv-hooks "virtualenv : echo"
stub pyenv-rehash " : echo rehashed"
}
unstub_pyenv() {
unstub pyenv-prefix
unstub pyenv-hooks
unstub pyenv-rehash
teardown_version "${PYENV_VERSION}"
}
@test "create virtualenv from given version" {
export PYENV_VERSION="2.7.11"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\"; mkdir -p \"\$2/bin\""
stub pyenv-exec "python -s -m ensurepip : false"
stub pyenv-exec "python -s */get-pip.py : true"
stub curl true
create_executable "${PYENV_VERSION}" "python-config"
create_executable "${PYENV_VERSION}" "python2-config"
create_executable "${PYENV_VERSION}" "python2.7-config"
run pyenv-virtualenv "2.7.11" "venv"
assert_output <<OUT
PYENV_VERSION=2.7.11 virtualenv ${PYENV_ROOT}/versions/2.7.11/envs/venv
Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
rehashed
OUT
assert_success
for x in pydoc python-config python2-config python2.7-config; do
assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/$x" ]
done
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
unstub curl
}
@test "create virtualenv from a given prefix" {
stub_pyenv "2.7.11"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : false"
stub pyenv-exec "python -s */get-pip.py : true"
stub curl true
stub pyenv-latest "-f 2.7 : echo 2.7.11"
run pyenv-virtualenv "2.7" "venv"
assert_output <<OUT
PYENV_VERSION=2.7.11 virtualenv ${PYENV_ROOT}/versions/2.7.11/envs/venv
Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/pydoc" ]
assert [ ! -e "${PYENV_ROOT}/versions/2.7" ]
assert_success
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
unstub curl
}
@test "create virtualenv from current version" {
export PYENV_VERSION="2.7.11"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-version-name "echo \${PYENV_VERSION}"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : false"
stub pyenv-exec "python -s */get-pip.py : true"
stub curl true
run pyenv-virtualenv venv
assert_output <<OUT
PYENV_VERSION=2.7.11 virtualenv ${PYENV_ROOT}/versions/2.7.11/envs/venv
Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
unstub curl
}
@test "create virtualenv with short options" {
export PYENV_VERSION="2.7.11"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-version-name "echo \${PYENV_VERSION}"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : false"
stub pyenv-exec "python -s */get-pip.py : true"
stub curl true
run pyenv-virtualenv -v -p ${TMP}/python venv
assert_output <<OUT
PYENV_VERSION=2.7.11 virtualenv --verbose --python=${TMP}/python ${PYENV_ROOT}/versions/2.7.11/envs/venv
Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
unstub curl
}
@test "create virtualenv with long options" {
export PYENV_VERSION="2.7.11"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-version-name "echo \${PYENV_VERSION}"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : false"
stub pyenv-exec "python -s */get-pip.py : true"
stub curl true
run pyenv-virtualenv --verbose --python=${TMP}/python venv
assert_output <<OUT
PYENV_VERSION=2.7.11 virtualenv --verbose --python=${TMP}/python ${PYENV_ROOT}/versions/2.7.11/envs/venv
Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
unstub curl
}
@test "no whitespace allowed in virtualenv name" {
run pyenv-virtualenv "2.7.11" "foo bar"
assert_failure
assert_output <<OUT
pyenv-virtualenv: no whitespace allowed in virtualenv name.
OUT
}
@test "no tab allowed in virtualenv name" {
run pyenv-virtualenv "2.7.11" "foo bar baz"
assert_failure
assert_output <<OUT
pyenv-virtualenv: no whitespace allowed in virtualenv name.
OUT
}
@test "system not allowed as virtualenv name" {
run pyenv-virtualenv "2.7.11" "system"
assert_failure
assert_output <<OUT
pyenv-virtualenv: \`system' is not allowed as virtualenv name.
OUT
}
@test "no slash allowed in virtualenv name" {
run pyenv-virtualenv "2.7.11" "foo/bar"
assert_failure
assert_output <<OUT
pyenv-virtualenv: no slash allowed in virtualenv name.
OUT
}
@test "slash allowed if it is the long name of the virtualenv" {
export PYENV_VERSION="2.7.11"
stub_pyenv "${PYENV_VERSION}"
stub pyenv-virtualenv-prefix " : false"
stub pyenv-exec "python -m venv --help : false"
stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
stub pyenv-exec "python -s -m ensurepip : false"
stub pyenv-exec "python -s */get-pip.py : true"
stub curl true
run pyenv-virtualenv "2.7.11" "2.7.11/envs/foo"
assert_output <<OUT
PYENV_VERSION=2.7.11 virtualenv ${PYENV_ROOT}/versions/2.7.11/envs/foo
Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
rehashed
OUT
assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/foo/bin/pydoc" ]
assert_success
unstub_pyenv
unstub pyenv-virtualenv-prefix
unstub pyenv-exec
unstub curl
}
================================================
FILE: test/virtualenvs.bats
================================================
#!/usr/bin/env bats
load test_helper
setup() {
export PYENV_ROOT="${TMP}/pyenv"
mkdir -p "${PYENV_ROOT}/versions/2.7.6"
mkdir -p "${PYENV_ROOT}/versions/3.3.3"
mkdir -p "${PYENV_ROOT}/versions/venv27"
mkdir -p "${PYENV_ROOT}/versions/venv33"
}
@test "list virtual environments only" {
stub pyenv-version-name ": echo system"
stub pyenv-virtualenv-prefix "2.7.6 : false"
stub pyenv-virtualenv-prefix "3.3.3 : false"
stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/2.7.6\""
stub pyenv-virtualenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/3.3.3\""
run pyenv-virtualenvs
assert_success
assert_output <<OUT
venv27 (created from ${PYENV_ROOT}/versions/2.7.6)
venv33 (created from ${PYENV_ROOT}/versions/3.3.3)
OUT
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
}
@test "list virtual environments with hit prefix" {
stub pyenv-version-name ": echo venv33"
stub pyenv-virtualenv-prefix "2.7.6 : false"
stub pyenv-virtualenv-prefix "3.3.3 : false"
stub pyenv-virtualenv-prefix "venv27 : echo \"/usr\""
stub pyenv-virtualenv-prefix "venv33 : echo \"/usr\""
run pyenv-virtualenvs
assert_success
assert_output <<OUT
venv27 (created from /usr)
* venv33 (created from /usr)
OUT
unstub pyenv-version-name
unstub pyenv-virtualenv-prefix
}
@test "list virtual environments with --bare" {
stub pyenv-virtualenv-prefix "2.7.6 : false"
stub pyenv-virtualenv-prefix "3.3.3 : false"
stub pyenv-virtualenv-prefix "venv27 : echo \"/usr\""
stub pyenv-virtualenv-prefix "venv33 : echo \"/usr\""
run pyenv-virtualenvs --bare
assert_success
assert_output <<OUT
venv27
venv33
OUT
unstub pyenv-virtualenv-prefix
}
gitextract_nqzhc3gf/
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ └── feature_request.md
│ ├── no-response.yml
│ └── workflows/
│ └── tests.yml
├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── LICENSE
├── MAINTENANCE.md
├── README.md
├── bin/
│ ├── pyenv-activate
│ ├── pyenv-deactivate
│ ├── pyenv-sh-activate
│ ├── pyenv-sh-deactivate
│ ├── pyenv-virtualenv
│ ├── pyenv-virtualenv-delete
│ ├── pyenv-virtualenv-init
│ ├── pyenv-virtualenv-prefix
│ └── pyenv-virtualenvs
├── etc/
│ └── pyenv.d/
│ ├── rehash/
│ │ └── envs.bash
│ ├── uninstall/
│ │ └── envs.bash
│ └── which/
│ ├── conda.bash
│ ├── python-config.bash
│ └── system-site-packages.bash
├── install.sh
├── libexec/
│ └── pyenv-virtualenv-realpath
├── shims/
│ ├── activate
│ └── deactivate
└── test/
├── activate.bats
├── conda-activate.bats
├── conda-deactivate.bats
├── conda-prefix.bats
├── conda.bats
├── deactivate.bats
├── delete.bats
├── envs.bats
├── hooks.bats
├── init.bats
├── installer.bats
├── pip.bats
├── prefix.bats
├── python.bats
├── pyvenv.bats
├── stubs/
│ └── stub
├── test_helper.bash
├── version.bats
├── virtualenv.bats
└── virtualenvs.bats
Condensed preview — 49 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (187K chars).
[
{
"path": ".github/FUNDING.yml",
"chars": 725,
"preview": "# These are supported funding model platforms\n\ngithub: [pyenv] # Replace with up to 4 GitHub Sponsors-enabled usernames "
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 2434,
"preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n### Prerequisite"
},
{
"path": ".github/ISSUE_TEMPLATE/feature_request.md",
"chars": 1047,
"preview": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Describe th"
},
{
"path": ".github/no-response.yml",
"chars": 695,
"preview": "# Configuration for probot-no-response - https://github.com/probot/no-response\n\n# Number of days of inactivity before an"
},
{
"path": ".github/workflows/tests.yml",
"chars": 439,
"preview": "name: tests\non: [pull_request, push]\njobs:\n tests:\n strategy:\n fail-fast: false\n matrix:\n os:\n "
},
{
"path": ".gitignore",
"chars": 163,
"preview": "/bats/\n/libexec/pyenv-virtualenv/*/*.class\n/libexec/pyenv-virtualenv/*/*.pyc\n/libexec/pyenv-virtualenv/*/*.pyo\n/libexec/"
},
{
"path": ".travis.yml",
"chars": 451,
"preview": "sudo: false\ninstall: git clone --depth=1 https://github.com/sstephenson/bats.git\nscript: bats/bin/bats --tap test\nlangua"
},
{
"path": "CHANGELOG.md",
"chars": 12375,
"preview": "## Version History\n\n#### v1.2.6\n* Fix changelog and version numbers\n\n#### v1.2.5\n* Add prompt customization by @jimenezj"
},
{
"path": "LICENSE",
"chars": 1058,
"preview": "Copyright (c) 2025 Yamashita, Yuu\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this "
},
{
"path": "MAINTENANCE.md",
"chars": 1041,
"preview": "Creating a release\n==================\n\nThe release of the new version of Pyenv is done via GitHub Releases.\n\nRelease che"
},
{
"path": "README.md",
"chars": 10496,
"preview": "# pyenv-virtualenv\n\n[![Join the chat at https://gitter.im/yyuu/pyenv-virtualenv](https://badges.gitter.im/Join%20Chat.sv"
},
{
"path": "bin/pyenv-activate",
"chars": 788,
"preview": "#!/usr/bin/env bash\n#\n# Summary: Activate virtual environment\n#\n# Usage: pyenv activate <virtualenv>\n# pyenv acti"
},
{
"path": "bin/pyenv-deactivate",
"chars": 440,
"preview": "#!/usr/bin/env bash\n#\n# Summary: Deactivate virtual environment\n#\n# Usage: pyenv deactivate\n#\n# Deactivate a Python virt"
},
{
"path": "bin/pyenv-sh-activate",
"chars": 7307,
"preview": "#!/usr/bin/env bash\n#\n# Summary: Activate virtual environment\n#\n# Usage: pyenv activate <virtualenv>\n# pyenv acti"
},
{
"path": "bin/pyenv-sh-deactivate",
"chars": 4149,
"preview": "#!/usr/bin/env bash\n#\n# Summary: Deactivate virtual environment\n#\n# Usage: pyenv deactivate\n#\n# Deactivate a Python virt"
},
{
"path": "bin/pyenv-virtualenv",
"chars": 19282,
"preview": "#!/usr/bin/env bash\n#\n# Summary: Create a Python virtualenv using the pyenv-virtualenv plugin\n#\n# Usage: pyenv virtualen"
},
{
"path": "bin/pyenv-virtualenv-delete",
"chars": 2537,
"preview": "#!/usr/bin/env bash\n#\n# Summary: Uninstall a specific Python virtualenv\n#\n# Usage: pyenv virtualenv-delete [-f|--force] "
},
{
"path": "bin/pyenv-virtualenv-init",
"chars": 3131,
"preview": "#!/usr/bin/env bash\n# Summary: Configure the shell environment for pyenv-virtualenv\n# Usage: eval \"$(pyenv virtualenv-in"
},
{
"path": "bin/pyenv-virtualenv-prefix",
"chars": 3149,
"preview": "#!/usr/bin/env bash\n#\n# Summary: Display real_prefix for a Python virtualenv version\n# Usage: pyenv virtualenv-prefix [<"
},
{
"path": "bin/pyenv-virtualenvs",
"chars": 2809,
"preview": "#!/usr/bin/env bash\n#\n# Summary: List all Python virtualenvs found in `$PYENV_ROOT/versions/*'.\n# Usage: pyenv virtualen"
},
{
"path": "etc/pyenv.d/rehash/envs.bash",
"chars": 288,
"preview": "virtualenv_list_executable_names() {\n local file\n shopt -s nullglob\n for file in \"$PYENV_ROOT\"/versions/*/envs/*/bin/"
},
{
"path": "etc/pyenv.d/uninstall/envs.bash",
"chars": 1144,
"preview": "resolve_link() {\n $(type -p greadlink readlink | head -1) \"$1\"\n}\n\nuninstall_related_virtual_env() {\n if [ -n \"${DEFINI"
},
{
"path": "etc/pyenv.d/which/conda.bash",
"chars": 468,
"preview": "# newer versions of conda share programs from the real prefix\n# this hook tries to find the executable there\n\nif [ ! -x "
},
{
"path": "etc/pyenv.d/which/python-config.bash",
"chars": 1853,
"preview": "# some of libraries require `python-config` in PATH to build native extensions.\n# as a workaround, this hook will try to"
},
{
"path": "etc/pyenv.d/which/system-site-packages.bash",
"chars": 2416,
"preview": "# if virtualenv is created with `--system-site-packages`,\n# looks up executables for source version as well if none is\n#"
},
{
"path": "install.sh",
"chars": 647,
"preview": "#!/bin/sh\n# Usage: PREFIX=/usr/local ./install.sh\n#\n# Installs pyenv-virtualenv under $PREFIX.\n\nset -e\n\ncd \"$(dirname \"$"
},
{
"path": "libexec/pyenv-virtualenv-realpath",
"chars": 1107,
"preview": "#!/usr/bin/env bash\n# Summary: Substitute realpath if unavailable as a builtin or file\n# Usage: . pyenv-virtualenv-realp"
},
{
"path": "shims/activate",
"chars": 247,
"preview": "#!/usr/bin/env bash\nif [[ \"$0\" != \"${BASH_SOURCE}\" ]]; then\n eval \"$(pyenv sh-activate --verbose \"$@\" || true)\"\nelse\n "
},
{
"path": "shims/deactivate",
"chars": 239,
"preview": "#!/usr/bin/env bash\nif [[ \"$0\" != \"${BASH_SOURCE}\" ]]; then\n eval \"$(pyenv sh-deactivate --verbose \"$@\" || true)\"\nelse\n"
},
{
"path": "test/activate.bats",
"chars": 15378,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export HOME=\"${TMP}\"\n export PYENV_ROOT=\"${TMP}/pyenv\"\n unset PYENV"
},
{
"path": "test/conda-activate.bats",
"chars": 7662,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export HOME=\"${TMP}\"\n export PYENV_ROOT=\"${TMP}/pyenv\"\n unset PYENV"
},
{
"path": "test/conda-deactivate.bats",
"chars": 3423,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n unset PYENV_VERSION\n unset PYENV_"
},
{
"path": "test/conda-prefix.bats",
"chars": 994,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n}\n\n@test \"display conda root\" {\n se"
},
{
"path": "test/conda.bats",
"chars": 2651,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n}\n\nstub_pyenv() {\n stub pyenv-versi"
},
{
"path": "test/deactivate.bats",
"chars": 10074,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n unset PYENV_VERSION\n unset PYENV_"
},
{
"path": "test/delete.bats",
"chars": 2037,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n}\n\n@test \"delete virtualenv\" {\n mkd"
},
{
"path": "test/envs.bats",
"chars": 1406,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/envs/pyenv\"\n}\n\nstub_pyenv() {\n stub pyenv-"
},
{
"path": "test/hooks.bats",
"chars": 3003,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n export HOOK_PATH=\"${TMP}/i has hoo"
},
{
"path": "test/init.bats",
"chars": 3423,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\n@test \"detect parent shell\" {\n unset PYENV_SHELL\n SHELL=/bin/false run pyenv-vi"
},
{
"path": "test/installer.bats",
"chars": 1063,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\n@test \"installs pyenv-virtualenv into PREFIX\" {\n cd \"$TMP\"\n PREFIX=\"${PWD}/usr\""
},
{
"path": "test/pip.bats",
"chars": 2458,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n}\n\nstub_pyenv() {\n stub pyenv-versi"
},
{
"path": "test/prefix.bats",
"chars": 6551,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n}\n\ncreate_version() {\n mkdir -p \"${"
},
{
"path": "test/python.bats",
"chars": 3524,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n export PYENV_VERSION=\"2.7.8\"\n set"
},
{
"path": "test/pyvenv.bats",
"chars": 5643,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n}\n\nstub_pyenv() {\n stub pyenv-versi"
},
{
"path": "test/stubs/stub",
"chars": 7601,
"preview": "#!/usr/bin/env bash\nexport PS4='+($$:${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'\nset -e\n\nstatus=0\npro"
},
{
"path": "test/test_helper.bash",
"chars": 4670,
"preview": "export TMP=\"$BATS_TEST_DIRNAME/tmp\"\nexport PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'\n\nPATH=/"
},
{
"path": "test/version.bats",
"chars": 917,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n}\n\n@test \"display virtualenv version"
},
{
"path": "test/virtualenv.bats",
"chars": 6705,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n}\n\nstub_pyenv() {\n setup_version \"$"
},
{
"path": "test/virtualenvs.bats",
"chars": 1706,
"preview": "#!/usr/bin/env bats\n\nload test_helper\n\nsetup() {\n export PYENV_ROOT=\"${TMP}/pyenv\"\n mkdir -p \"${PYENV_ROOT}/versions/2"
}
]
About this extraction
This page contains the full source code of the pyenv/pyenv-virtualenv GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 49 files (169.7 KB), approximately 54.7k tokens. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.