def create_virtual_env(project_path, install_path):
# remove existing virtual env if exists
ve_path = os.path.join(project_path, cfg.VIRTUAL_ENV_PATH)
if os.path.exists(ve_path):
shutil.rmtree(ve_path)
try:
logger.info('creating virtual env')
virtualenv.create_environment(ve_path)
except Exception:
logger.exception('failed to create virtualenv: ')
raise Exception('failed to create virtualenv!')
try:
logger.info('installing requirements for virtualenv')
# update pip to latest version
run_command(['{}/ve/bin/pip'.format(project_path),
'install',
'-U',
'pip'])
if not os.path.exists('{}/requirements.txt'.format(project_path)):
logger.warning('requirements.txt not found')
return ve_path
run_command(['{}/ve/bin/pip'.format(project_path),
'install',
'-r',
'{}/requirements.txt'.format(project_path)])
virtualenv.make_environment_relocatable(ve_path)
fixup_scripts(install_path, ve_path)
except Exception:
logger.exception('failed to install requirements! error message:')
raise Exception('fail to install requirements.')
return ve_path
def run(self):
# generate the metadata first
self.run_command('egg_info')
venv_dir = self.bdist_dir
virtualenv.create_environment(
venv_dir,
never_download=True,
)
pip_cmd = [os.path.join(venv_dir, 'bin', 'pip'), 'install', '.']
if self.requirements:
pip_cmd.extend(['-r', self.requirements])
subprocess.check_call(pip_cmd)
self.copy_file(os.path.join(self.egg_info, 'PKG-INFO'), venv_dir)
virtualenv.make_environment_relocatable(venv_dir)
log.info("creating '%s' and adding '%s' to it", self.venv_output,
venv_dir)
mkpath(os.path.dirname(self.venv_output))
with closing(tarfile.open(self.venv_output, 'w:gz')) as tar:
tar.add(venv_dir, self.archive_root)
self.distribution.dist_files.append(('bdist_venv', get_python_version(),
self.venv_output))
if not self.keep_temp:
remove_tree(venv_dir)
def install(self, name, version=None, develop=False, upgrade=False, install_options=None):
"""
install is used when installing a python package into the environment.
if version is set, the specified version of the package will be installed.
The specified version should be a full `PEP 440`_ version specifier (i.e. "==1.2.0")
.. _`PEP 440`: https://www.python.org/dev/peps/pep-0440/
if develop is set to True, the package will be installed as editable: the source
in the directory passed will be used when using that package.
if install_options is provided, it should be a list of options, like
["--prefix=/opt/srv", "--install-lib=/opt/srv/lib"]
"""
if self._is_package_already_installed(name, version):
return
p_assert(
not (develop and version),
"unable to set both version and develop flags when installing packages"
)
if name in self.versions:
if version is None:
version = self.versions[name]
del self.versions[name]
req_set = install(
name, upgrade=upgrade, develop=develop, version=version,
index_urls=self.index_urls, constraint_dict=self.versions,
packages_config=self.config,
install_options=install_options
)
if req_set:
for req in req_set.requirements.values():
# Don't examine packages that weren't modified
if not req.install_succeeded:
continue
# Retrieving a package's installed version is time consuming.
# Prefer the calculated package specifier if available, and use
# the installed version if not.
new_constraint = str(req.specifier) if req.specifier else None
if not new_constraint:
installed_version = req.installed_version
if installed_version:
new_constraint = '=={}'.format(installed_version)
if new_constraint:
self.versions[req.name] = new_constraint
# if virtualenv dir is set, we should make the environment relocatable.
# this will fix issues with commands not being usable by the
# uranium via build.executables.run
if self._virtualenv_dir:
virtualenv.make_environment_relocatable(self._virtualenv_dir)
# there's a caveat that requires the site packages to be reloaded,
# if the package is a develop package. This is to enable
# immediately consuming the package after install.
self._reimport_site_packages()
# invalidate the finder's cache, to ensure new modules are
# picked up
invalidate_caches()
def activate_env(env, deps, quiet=False):
if hasattr(sys, 'real_prefix'):
LOGGER.error('Already activated environment!')
return
if not quiet:
print 'Activating environment: %r' % env
assert isinstance(deps, dict)
manifest_path = os.path.join(env, 'manifest.pyl')
cur_deps = read_deps(manifest_path)
if cur_deps != deps:
if not quiet:
print ' Removing old environment: %r' % cur_deps
shutil.rmtree(env, ignore_errors=True)
cur_deps = None
if cur_deps is None:
check_pydistutils()
if not quiet:
print ' Building new environment'
# Add in bundled virtualenv lib
sys.path.insert(0, os.path.join(os.path.dirname(__file__),
'virtualenv'))
import virtualenv # pylint: disable=F0401
virtualenv.create_environment(
env, search_dirs=virtualenv.file_search_dirs())
if not quiet:
print ' Activating environment'
# Ensure hermeticity during activation.
os.environ.pop('PYTHONPATH', None)
bin_dir = 'Scripts' if sys.platform.startswith('win') else 'bin'
activate_this = os.path.join(env, bin_dir, 'activate_this.py')
execfile(activate_this, dict(__file__=activate_this))
if cur_deps is None:
if not quiet:
print ' Installing deps'
print_deps(deps, indent=2, with_implicit=False)
install(deps)
virtualenv.make_environment_relocatable(env)
with open(manifest_path, 'wb') as f:
f.write(repr(deps) + '\n')
# Create bin\python.bat on Windows to unify path where Python is found.
if sys.platform.startswith('win'):
bin_path = os.path.join(env, 'bin')
if not os.path.isdir(bin_path):
os.makedirs(bin_path)
python_bat_path = os.path.join(bin_path, 'python.bat')
if not os.path.isfile(python_bat_path):
with open(python_bat_path, 'w') as python_bat_file:
python_bat_file.write(PYTHON_BAT_WIN)
if not quiet:
print 'Done creating environment'
def activate_env(env, deps, quiet=False):
if hasattr(sys, 'real_prefix'):
LOGGER.error('Already activated environment!')
return
if not quiet:
print 'Activating environment: %r' % env
assert isinstance(deps, dict)
manifest_path = os.path.join(env, 'manifest.pyl')
cur_deps = read_deps(manifest_path)
if cur_deps != deps:
if not quiet:
print ' Removing old environment: %r' % cur_deps
shutil.rmtree(env, ignore_errors=True)
cur_deps = None
if cur_deps is None:
check_pydistutils()
if not quiet:
print ' Building new environment'
# Add in bundled virtualenv lib
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'virtualenv'))
import virtualenv # pylint: disable=F0401
virtualenv.create_environment(
env, search_dirs=virtualenv.file_search_dirs())
if not quiet:
print ' Activating environment'
# Ensure hermeticity during activation.
os.environ.pop('PYTHONPATH', None)
bin_dir = 'Scripts' if sys.platform.startswith('win') else 'bin'
activate_this = os.path.join(env, bin_dir, 'activate_this.py')
execfile(activate_this, dict(__file__=activate_this))
if cur_deps is None:
if not quiet:
print ' Installing deps'
print_deps(deps, indent=2, with_implicit=False)
install(deps)
virtualenv.make_environment_relocatable(env)
with open(manifest_path, 'wb') as f:
f.write(repr(deps) + '\n')
# Create bin\python.bat on Windows to unify path where Python is found.
if sys.platform.startswith('win'):
bin_path = os.path.join(env, 'bin')
if not os.path.isdir(bin_path):
os.makedirs(bin_path)
python_bat_path = os.path.join(bin_path, 'python.bat')
if not os.path.isfile(python_bat_path):
with open(python_bat_path, 'w') as python_bat_file:
python_bat_file.write(PYTHON_BAT_WIN)
if not quiet:
print 'Done creating environment'
def _finalize(self):
virtualenv.make_environment_relocatable(self._root)
activate_content = ""
activate_content += self.envvars.generate_activate_content()
write_activate_this(self._root, additional_content=activate_content)
self.history[HISTORY_KEY] = {
"python_version": "{0}.{1}".format(*sys.version_info[:2])
}
self.history.save()
def create_virtualenv(bundle_path, requirements_path):
import compileall
import pip
import virtualenv
scripts_path = os.path.join(bundle_path, 'Contents', 'Scripts')
virtualenv.create_environment(scripts_path, site_packages=True)
virtualenv.make_environment_relocatable(scripts_path)
pip.main(['install', '--prefix', scripts_path, '-r', requirements_path])
compileall.compile_dir(scripts_path, maxlevels=0)
def activate_env(env, manifest, quiet=False):
if not quiet:
print 'Activating environment: %r' % env
assert isinstance(manifest, dict)
manifest_path = os.path.join(env, 'manifest.pyl')
cur_manifest = read_python_literal(manifest_path)
if cur_manifest != manifest:
if not quiet:
print ' Removing old environment: %r' % cur_manifest
shutil.rmtree(env, ignore_errors=True)
cur_manifest = None
if cur_manifest is None:
check_pydistutils()
if not quiet:
print ' Building new environment'
# Add in bundled virtualenv lib
sys.path.insert(
0, os.path.join(os.path.dirname(__file__), 'virtualenv-ext'))
import virtualenv # pylint: disable=F0401
virtualenv.create_environment(
env, search_dirs=virtualenv.file_search_dirs())
if not quiet:
print ' Activating environment'
# Ensure hermeticity during activation.
os.environ.pop('PYTHONPATH', None)
bin_dir = 'Scripts' if sys.platform.startswith('win') else 'bin'
activate_this = os.path.join(env, bin_dir, 'activate_this.py')
execfile(activate_this, dict(__file__=activate_this))
if cur_manifest is None:
deps = manifest.get('deps', {})
if not quiet:
print ' Installing deps'
print_deps(deps, indent=2, with_implicit=False)
install(deps)
virtualenv.make_environment_relocatable(env)
# Write the original deps (including metadata) as manifest.
with open(manifest_path, 'wb') as f:
f.write(repr(manifest) + '\n')
# Create bin\python.bat on Windows to unify path where Python is found.
if sys.platform.startswith('win'):
bin_path = os.path.join(env, 'bin')
if not os.path.isdir(bin_path):
os.makedirs(bin_path)
python_bat_path = os.path.join(bin_path, 'python.bat')
if not os.path.isfile(python_bat_path):
with open(python_bat_path, 'w') as python_bat_file:
python_bat_file.write(PYTHON_BAT_WIN)
if not quiet:
print 'Done creating environment'
def _finalize(self):
virtualenv.make_environment_relocatable(self._root)
activate_content = ""
activate_content += self.envvars.generate_activate_content()
write_activate_this(self._root, additional_content=activate_content)
self.history[HISTORY_KEY] = {
"python_version": "{0}.{1}".format(*sys.version_info[:2])
}
self.history.save()
def install_virtualenv(install_dir):
"""
install a virtualenv to the desired directory,
and returns the path to the executable.
"""
if is_virtualenv(install_dir):
return
create_environment(install_dir, no_setuptools=False,
no_pip=False, site_packages=False,
symlink=False)
make_environment_relocatable(install_dir)
return os.path.exists(install_dir, "bin")
def relocateable_ve(ve_dir):
log.debug('Making virtualenv relocatable')
virtualenv.make_environment_relocatable(ve_dir)
# Make activate relocatable, using approach taken in
# https://github.com/pypa/virtualenv/pull/236
activate = []
with open(os.path.join(ve_dir, 'bin', 'activate')) as f:
for line in f:
line = line.strip()
if line == 'deactivate () {':
activate += ['ACTIVATE_PATH_FALLBACK="$_"', '']
if line.startswith('VIRTUAL_ENV='):
activate += [
'# attempt to determine VIRTUAL_ENV in relocatable way',
'if [ ! -z "${BASH_SOURCE:-}" ]; then',
' # bash',
' ACTIVATE_PATH="${BASH_SOURCE}"',
'elif [ ! -z "${DASH_SOURCE:-}" ]; then',
' # dash',
' ACTIVATE_PATH="${DASH_SOURCE}"',
'elif [ ! -z "${ZSH_VERSION:-}" ]; then',
' # zsh',
' ACTIVATE_PATH="$0"',
'elif [ ! -z "${KSH_VERSION:-}" ] '
'|| [ ! -z "${.sh.version:}" ]; then',
' # ksh - we have to use history, '
'and unescape spaces before quoting',
' ACTIVATE_PATH="$(history -r -l -n | head -1 | sed -e '
'\'s/^[\\t ]*\\(\\.\\|source\\) *//;s/\\\\ / /g\')"',
'elif [ "$(basename "$ACTIVATE_PATH_FALLBACK")" == '
'"activate.sh" ]; then',
' ACTIVATE_PATH="${ACTIVATE_PATH_FALLBACK}"',
'else',
' ACTIVATE_PATH=""',
'fi',
'',
'# default to non-relocatable path',
]
if line == 'export VIRTUAL_ENV':
activate += [
'if [ ! -z "${ACTIVATE_PATH:-}" ]; then',
' VIRTUAL_ENV="$(cd '
'"$(dirname "${ACTIVATE_PATH}")/.."; pwd)"',
'fi',
'unset ACTIVATE_PATH',
'unset ACTIVATE_PATH_FALLBACK',
]
activate.append(line)
with open(os.path.join(ve_dir, 'bin', 'activate'), 'w') as f:
f.write('\n'.join(activate))
def install_virtualenv(install_dir):
"""
install a virtualenv to the desired directory,
and returns the path to the executable.
"""
if is_virtualenv(install_dir):
return
create_environment(install_dir,
no_setuptools=False,
no_pip=False,
site_packages=False,
symlink=False)
make_environment_relocatable(install_dir)
return os.path.exists(install_dir, "bin")
def _create(self, clear=False, pip_source_dir=None, relocatable=False):
# Create the actual virtual environment
_virtualenv.create_environment(
self.location,
clear=clear,
download=False,
no_pip=True,
no_wheel=True,
)
_virtualenv.install_wheel([pip_source_dir or '.'],
self.bin.join("python"))
if relocatable:
_virtualenv.make_environment_relocatable(self.location)
# FIXME: some tests rely on 'easy-install.pth' being already present.
site_package = distutils.sysconfig.get_python_lib(prefix=self.location)
Path(site_package).join('easy-install.pth').touch()
def _create(self, clear=False, pip_source_dir=None, relocatable=False):
# Create the actual virtual environment
_virtualenv.create_environment(
self.location,
clear=clear,
download=False,
no_pip=True,
no_wheel=True,
)
_virtualenv.install_wheel([pip_source_dir or '.'],
self.bin.join("python"))
if relocatable:
_virtualenv.make_environment_relocatable(self.location)
# FIXME: some tests rely on 'easy-install.pth' being already present.
site_package = distutils.sysconfig.get_python_lib(prefix=self.location)
Path(site_package).join('easy-install.pth').touch()
def install(self,
name,
version=None,
develop=False,
upgrade=False,
install_options=None):
"""
install is used when installing a python package into the environment.
if version is set, the specified version of the package will be installed.
The specified version should be a full `PEP 440`_ version specifier (i.e. "==1.2.0")
.. _`PEP 440`: https://www.python.org/dev/peps/pep-0440/
if develop is set to True, the package will be installed as editable: the source
in the directory passed will be used when using that package.
if install_options is provided, it should be a list of options, like
["--prefix=/opt/srv", "--install-lib=/opt/srv/lib"]
"""
if self._is_package_already_installed(name, version):
return
p_assert(
not (develop and version),
"unable to set both version and develop flags when installing packages"
)
if name in self.versions:
if version is None:
version = self.versions[name]
del self.versions[name]
req_set = install(name,
upgrade=upgrade,
develop=develop,
version=version,
index_urls=self.index_urls,
constraint_dict=self.versions,
install_options=install_options)
if req_set:
for req in req_set.requirements.values():
if req.installed_version:
self.versions[req.name] = ("==" + req.installed_version)
# if virtualenv dir is set, we should make the environment relocatable.
# this will fix issues with commands not being usable by the
# uranium via build.executables.run
if self._virtualenv_dir:
virtualenv.make_environment_relocatable(self._virtualenv_dir)
def create_virtual_env(project_path, install_path, ve_args):
# remove existing virtual env if exists
ve_path = os.path.join(project_path, cfg.VIRTUAL_ENV_PATH)
if os.path.exists(ve_path):
shutil.rmtree(ve_path)
try:
logger.info('creating virtual env')
sys.argv = ['']
if '--no-wheel' not in ve_args:
sys.argv.append('--no-wheel')
sys.argv.extend(ve_args)
sys.argv.append(ve_path)
try:
virtualenv.main()
except SystemExit as sysext:
if sysext.code != 0:
raise SystemExit(sysext)
except Exception:
logger.exception('failed to create virtualenv: ')
raise Exception('failed to create virtualenv!')
try:
logger.info('installing requirements for virtualenv')
# update pip to latest version
run_command(['{}/{}/bin/pip'.format(project_path,
cfg.VIRTUAL_ENV_PATH),
'install',
'-U',
'pip'])
if not os.path.exists('{}/requirements.txt'.format(project_path)):
logger.warning('requirements.txt not found')
return ve_path
run_command(['{}/{}/bin/pip'.format(project_path,
cfg.VIRTUAL_ENV_PATH),
'install',
'-r',
'{}/requirements.txt'.format(project_path)])
virtualenv.make_environment_relocatable(ve_path)
fixup_scripts(install_path, ve_path)
except Exception:
logger.exception('failed to install requirements! error message:')
raise Exception('fail to install requirements.')
return ve_path
def setup_virtualenv(env_path, relocatable=False):
"""Create a virtualenv in specified location.
The virtualenv contains a standard Python installation, plus setuptools, pip
and wheel.
Args:
env_path (str): where to create the virtual environment.
"""
if os.path.exists(os.path.join(os.path.expanduser('~'), '.pydistutils.cfg')):
raise GlycoSetupError('\n'.join([
'',
'You have a ~/.pydistutils.cfg file, which interferes with the ',
'infra virtualenv environment. Please move it to the side and bootstrap ',
'again. Once infra has bootstrapped, you may move it back.',
'',
'Upstream bug: https://github.com/pypa/virtualenv/issues/88/',
''
]))
print 'Creating environment: %r' % env_path
if os.path.exists(env_path):
print ' Removing existing one...'
shutil.rmtree(env_path, ignore_errors=True)
print ' Building new environment...'
# Import bundled virtualenv lib
import virtualenv # pylint: disable=F0401
virtualenv.create_environment(
env_path, search_dirs=virtualenv.file_search_dirs())
if relocatable:
print ' Make environment relocatable'
virtualenv.make_environment_relocatable(env_path)
print 'Done creating environment'
def setup_virtualenv(env_path, relocatable=False):
"""Create a virtualenv in specified location.
The virtualenv contains a standard Python installation, plus setuptools, pip
and wheel.
Args:
env_path (str): where to create the virtual environment.
"""
if os.path.exists(os.path.join(os.path.expanduser('~'),
'.pydistutils.cfg')):
raise GlycoSetupError('\n'.join([
'',
'You have a ~/.pydistutils.cfg file, which interferes with the ',
'infra virtualenv environment. Please move it to the side and bootstrap ',
'again. Once infra has bootstrapped, you may move it back.', '',
'Upstream bug: https://github.com/pypa/virtualenv/issues/88/', ''
]))
print 'Creating environment: %r' % env_path
if os.path.exists(env_path):
print ' Removing existing one...'
shutil.rmtree(env_path, ignore_errors=True)
print ' Building new environment...'
# Import bundled virtualenv lib
import virtualenv # pylint: disable=F0401
virtualenv.create_environment(env_path,
search_dirs=virtualenv.file_search_dirs())
if relocatable:
print ' Make environment relocatable'
virtualenv.make_environment_relocatable(env_path)
print 'Done creating environment'
def create_virtualenv(bundle_path, requirements_path):
scripts_path = os.path.join(bundle_path, 'Contents', 'Scripts')
virtualenv.create_environment(scripts_path, site_packages=True)
virtualenv.make_environment_relocatable(scripts_path)
pip(['install', '--prefix', scripts_path, '-r', requirements_path])
compileall.compile_dir(scripts_path, maxlevels=0)
def relocateable_ve(ve_dir, python_version):
# We can only call into the virtualenv module for operating on a
# Python 2 virtualenv, in Python 2.
if sys.version_info.major == 3 and python_version == '2.7':
cmd = [
os.path.join(ve_dir, 'bin', 'python'), '-c',
'import sys; sys.path.append("%(ve_path)s"); '
'sys.path.append("%(my_path)s"); '
'from yodeploy import virtualenv; '
'virtualenv.relocateable_ve("%(ve_dir)s", "%(python_version)s")'
% {
've_path': os.path.dirname(virtualenv.__file__),
'my_path': os.path.join(os.path.dirname(__file__), '..'),
've_dir': ve_dir,
'python_version': python_version,
}]
subprocess.check_call(cmd)
return
log.debug('Making virtualenv relocatable')
# Python 3 venv virtualenvs don't have these problems
if python_version == '2.7':
virtualenv.make_environment_relocatable(ve_dir)
fix_local_symlinks(ve_dir)
remove_fragile_symlinks(ve_dir)
# Make activate relocatable, using approach taken in
# https://github.com/pypa/virtualenv/pull/236
activate = []
with open(os.path.join(ve_dir, 'bin', 'activate')) as f:
for line in f:
line = line.strip()
if line == 'deactivate () {':
activate += ['ACTIVATE_PATH_FALLBACK="$_"', '']
if line.startswith('VIRTUAL_ENV='):
activate += [
'# attempt to determine VIRTUAL_ENV in relocatable way',
'if [ ! -z "${BASH_SOURCE:-}" ]; then',
' # bash',
' ACTIVATE_PATH="${BASH_SOURCE}"',
'elif [ ! -z "${DASH_SOURCE:-}" ]; then',
' # dash',
' ACTIVATE_PATH="${DASH_SOURCE}"',
'elif [ ! -z "${ZSH_VERSION:-}" ]; then',
' # zsh',
' ACTIVATE_PATH="$0"',
'elif [ ! -z "${KSH_VERSION:-}" ] '
'|| [ ! -z "${.sh.version:}" ]; then',
' # ksh - we have to use history, '
'and unescape spaces before quoting',
' ACTIVATE_PATH="$(history -r -l -n | head -1 | sed -e '
'\'s/^[\\t ]*\\(\\.\\|source\\) *//;s/\\\\ / /g\')"',
'elif [ "$(basename "$ACTIVATE_PATH_FALLBACK")" == '
'"activate.sh" ]; then',
' ACTIVATE_PATH="${ACTIVATE_PATH_FALLBACK}"',
'else',
' ACTIVATE_PATH=""',
'fi',
'',
'# default to non-relocatable path',
]
if line == 'export VIRTUAL_ENV':
activate += [
'if [ ! -z "${ACTIVATE_PATH:-}" ]; then',
' VIRTUAL_ENV="$(cd '
'"$(dirname "${ACTIVATE_PATH}")/.."; pwd)"',
'fi',
'unset ACTIVATE_PATH',
'unset ACTIVATE_PATH_FALLBACK',
]
activate.append(line)
with open(os.path.join(ve_dir, 'bin', 'activate'), 'w') as f:
f.write('\n'.join(activate))
def activate_env(env, deps, quiet=False, run_within_virtualenv=False):
if hasattr(sys, 'real_prefix'):
if not run_within_virtualenv:
LOGGER.error('Already activated environment!')
return
LOGGER.info('Discarding current VirtualEnv (--run-within-virtualenv)')
sys.prefix = sys.real_prefix
if not quiet:
print 'Activating environment: %r' % env
assert isinstance(deps, dict)
manifest_path = os.path.join(env, 'manifest.pyl')
cur_deps = read_deps(manifest_path)
if cur_deps != deps:
if not quiet:
print ' Removing old environment: %r' % cur_deps
shutil.rmtree(env, ignore_errors=True)
cur_deps = None
if cur_deps is None:
check_pydistutils()
if not quiet:
print ' Building new environment'
# Add in bundled virtualenv lib
sys.path.insert(0, os.path.join(os.path.dirname(__file__),
'virtualenv'))
import virtualenv # pylint: disable=F0401
virtualenv.create_environment(
env, search_dirs=virtualenv.file_search_dirs())
# Hack: On windows orig-prefix.txt contains the hardcoded path
# "E:\b\depot_tools\python276_bin", but some systems have depot_tools
# installed on C:\ instead, so fiddle site.py to try loading it from there
# as well.
if sys.platform.startswith('win'):
site_py_path = os.path.join(env, 'Lib\\site.py')
with open(site_py_path) as fh:
site_py = fh.read()
m = re.search(r'( +)sys\.real_prefix = .*', site_py)
replacement = (
'%(indent)sif (sys.real_prefix.startswith("E:\\\\") and\n'
'%(indent)s not os.path.exists(sys.real_prefix)):\n'
'%(indent)s cand = "C:\\\\setup" + sys.real_prefix[4:]\n'
'%(indent)s if os.path.exists(cand):\n'
'%(indent)s sys.real_prefix = cand\n'
'%(indent)s else:\n'
'%(indent)s sys.real_prefix = "C" + sys.real_prefix'
'[1:]\n' % {
'indent': m.group(1)
})
site_py = site_py[:m.
end(0)] + '\n' + replacement + site_py[m.end(0):]
with open(site_py_path, 'w') as fh:
fh.write(site_py)
if not quiet:
print ' Activating environment'
# Ensure hermeticity during activation.
os.environ.pop('PYTHONPATH', None)
bin_dir = 'Scripts' if sys.platform.startswith('win') else 'bin'
activate_this = os.path.join(env, bin_dir, 'activate_this.py')
execfile(activate_this, dict(__file__=activate_this))
if cur_deps is None:
if not quiet:
print ' Installing deps'
print_deps(deps, indent=2, with_implicit=False)
install(deps)
virtualenv.make_environment_relocatable(env)
with open(manifest_path, 'wb') as f:
f.write(repr(deps) + '\n')
# Create bin\python.bat on Windows to unify path where Python is found.
if sys.platform.startswith('win'):
bin_path = os.path.join(env, 'bin')
if not os.path.isdir(bin_path):
os.makedirs(bin_path)
python_bat_path = os.path.join(bin_path, 'python.bat')
if not os.path.isfile(python_bat_path):
with open(python_bat_path, 'w') as python_bat_file:
python_bat_file.write(PYTHON_BAT_WIN)
if not quiet:
print 'Done creating environment'
def _finalize(self):
virtualenv.make_environment_relocatable(self._root)
activate_content = ""
activate_content += self.envvars.generate_activate_content()
write_activate_this(self._root, additional_content=activate_content)
self.history.save()
def run(self):
# create it
venv_dir = self.bdist_dir
if self.location_dir:
venv_dir = os.path.join(venv_dir, self.location_dir)
log.info('creating virtualenv "%s"', venv_dir)
virtualenv.create_environment(venv_dir, clear=True)
# install to
log.info('installing to virtualenv "%s"', venv_dir)
pip = os.path.join(venv_dir, 'bin', 'pip')
install_cmd = [pip, 'install', '.']
self.spawn(install_cmd)
if self.extras:
log.info('installing extras to virtualenv "%s"', venv_dir)
install_cmd = [pip, 'install']
for extra in self.extras:
extras_require = self.distribution.extras_require[extra]
if isinstance(extras_require, basestring):
extras_require = [extras_require]
install_cmd.extend(extras_require)
self.spawn(install_cmd)
# location
if self.location_dir:
log.info('making virtualenv "%s" installable to "%s"', venv_dir, self.location_dir)
self.fixup_shebangs(venv_dir)
self.fixup_virtual_envs(venv_dir)
self.fixup_links(venv_dir)
if self.keep_compiled:
self.fixup_compiled(venv_dir)
else:
self.remove_compiled(venv_dir)
else:
log.info('making virtualenv "%s" relocatable', venv_dir)
virtualenv.make_environment_relocatable(venv_dir)
self.remove_compiled(venv_dir)
# distribution
dist_root = os.path.join(self.dist_dir, self.dist_name)
if self.format:
# as archive
archive = self.make_archive(
dist_root,
self.format,
root_dir=self.bdist_dir,
owner=self.owner,
group=self.group,
)
self.distribution.dist_files.append(
('bdist_venv', get_python_version(), archive)
)
else:
# as directory
copy_tree(self.bdist_dir, dist_root, preserve_symlinks=1)
self.distribution.dist_files.append(
('bdist_venv', get_python_version(), dist_root)
)
# cleanup
if not self.keep_temp:
remove_tree(self.bdist_dir, dry_run=self.dry_run)
