'fnmatch', 'locale', 'encodings', 'codecs',

'stat', 'UserDict', 'readline', 'copy_reg', 'types',

're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile',

"""

DEBUG = logging.DEBUG

INFO = logging.INFO

NOTIFY = (logging.INFO + logging.WARN) / 2

WARN = WARNING = logging.WARN

ERROR = logging.ERROR

FATAL = logging.FATAL

LEVELS = [DEBUG, INFO, NOTIFY, WARN, ERROR, FATAL]

def __init__(self, consumers):

self.consumers = consumers

self.indent = 0

self.in_progress = None

self.in_progress_hanging = False

def debug(self, msg, *args, **kw):

self.log(self.DEBUG, msg, *args, **kw)

def info(self, msg, *args, **kw):

self.log(self.INFO, msg, *args, **kw)

def notify(self, msg, *args, **kw):

self.log(self.NOTIFY, msg, *args, **kw)

def warn(self, msg, *args, **kw):

self.log(self.WARN, msg, *args, **kw)

def error(self, msg, *args, **kw):

self.log(self.ERROR, msg, *args, **kw)

def fatal(self, msg, *args, **kw):

self.log(self.FATAL, msg, *args, **kw)

def log(self, level, msg, *args, **kw):

if args:

if kw:

raise TypeError(

"You may give positional or keyword arguments, not both")

args = args or kw

rendered = None

for consumer_level, consumer in self.consumers:

if self.level_matches(level, consumer_level):

if (self.in_progress_hanging

and consumer in (sys.stdout, sys.stderr)):

self.in_progress_hanging = False

sys.stdout.write('\n')

sys.stdout.flush()

if rendered is None:

if args:

rendered = msg % args

else:

rendered = msg

rendered = ' ' * self.indent + rendered

if hasattr(consumer, 'write'):

consumer.write(rendered + '\n')

else:

consumer(rendered)

def start_progress(self, msg):

assert not self.in_progress, (

"Tried to start_progress(%r) while in_progress %r"

% (msg, self.in_progress))

if self.level_matches(self.NOTIFY, self._stdout_level()):

sys.stdout.write(msg)

sys.stdout.flush()

self.in_progress_hanging = True

else:

self.in_progress_hanging = False

self.in_progress = msg

def end_progress(self, msg='done.'):

assert self.in_progress, (

"Tried to end_progress without start_progress")

if self.stdout_level_matches(self.NOTIFY):

if not self.in_progress_hanging:

# Some message has been printed out since start_progress

sys.stdout.write('...' + self.in_progress + msg + '\n')

sys.stdout.flush()

else:

sys.stdout.write(msg + '\n')

sys.stdout.flush()

self.in_progress = None

self.in_progress_hanging = False

def show_progress(self):

"""If we are in a progress scope, and no log messages have been

if self.in_progress_hanging:

sys.stdout.write('.')

sys.stdout.flush()

def stdout_level_matches(self, level):

"""Returns true if a message at this level will go to stdout"""

return self.level_matches(level, self._stdout_level())

def _stdout_level(self):

"""Returns the level that stdout runs at"""

for level, consumer in self.consumers:

if consumer is sys.stdout:

return level

return self.FATAL

def level_matches(self, level, consumer_level):

"""

if isinstance(level, slice):

start, stop = level.start, level.stop

if start is not None and start > consumer_level:

return False

if stop is not None and stop <= consumer_level:

return False

return True

else:

return level >= consumer_level

#@classmethod

def level_for_integer(cls, level):

levels = cls.LEVELS

if level < 0:

return levels[0]

if level >= len(levels):

return levels[-1]

return levels[level]

if not os.path.exists(path):

logger.info('Creating %s', path)

os.makedirs(path)

else:

if os.path.isdir(src):

shutil.copytree(src, dest, True)

else:

if not os.path.exists(src):

# Some bad symlink in the src

logger.warn('Cannot find file %s (bad symlink)', src)

return

if os.path.exists(dest):

logger.debug('File %s already exists', dest)

return

if not os.path.exists(os.path.dirname(dest)):

logger.info('Creating parent directories for %s' % os.path.dirname(dest))

os.makedirs(os.path.dirname(dest))

if not os.path.islink(src):

srcpath = os.path.abspath(src)

else:

srcpath = os.readlink(src)

if symlink and hasattr(os, 'symlink') and not is_win:

logger.info('Symlinking %s', dest)

try:

os.symlink(srcpath, dest)

except (OSError, NotImplementedError):

logger.info('Symlinking failed, copying to %s', dest)

copyfileordir(src, dest)

else:

logger.info('Copying to %s', dest)

if not os.path.exists(dest):

logger.info('Writing %s', dest)

f = open(dest, 'wb')

f.write(content.encode('utf-8'))

f.close()

return

else:

f = open(dest, 'rb')

c = f.read()

f.close()

if c != content.encode("utf-8"):

if not overwrite:

logger.notify('File %s exists with different content; not overwriting', dest)

return

logger.notify('Overwriting %s with new content', dest)

f = open(dest, 'wb')

f.write(content.encode('utf-8'))

f.close()

else:

if os.path.exists(dir):

logger.notify('Deleting tree %s', dir)

shutil.rmtree(dir)

else:

if hasattr(os, 'chmod'):

oldmode = os.stat(fn).st_mode & 0xFFF # 0o7777

newmode = (oldmode | 0x16D) & 0xFFF # 0o555, 0o7777

os.chmod(fn, newmode)

for dir in reversed(dirs):

files = glob.glob(os.path.join(dir, filename))

if files and os.path.isfile(files[0]):

return True, files[0]

search_dirs=None, never_download=False):

if search_dirs is None:

search_dirs = file_search_dirs()

if not distribute:

egg_path = 'setuptools-*-py%s.egg' % sys.version[:3]

found, egg_path = _find_file(egg_path, search_dirs)

project_name = 'setuptools'

bootstrap_script = EZ_SETUP_PY

tgz_path = None

else:

# Look for a distribute egg (these are not distributed by default,

# but can be made available by the user)

egg_path = 'distribute-*-py%s.egg' % sys.version[:3]

found, egg_path = _find_file(egg_path, search_dirs)

project_name = 'distribute'

if found:

tgz_path = None

bootstrap_script = DISTRIBUTE_FROM_EGG_PY

else:

# Fall back to sdist

# NB: egg_path is not None iff tgz_path is None

# iff bootstrap_script is a generic setup script accepting

# the standard arguments.

egg_path = None

tgz_path = 'distribute-*.tar.gz'

found, tgz_path = _find_file(tgz_path, search_dirs)

bootstrap_script = DISTRIBUTE_SETUP_PY

if is_jython and os._name == 'nt':

# Jython's .bat sys.executable can't handle a command line

# argument with newlines

fd, ez_setup = tempfile.mkstemp('.py')

os.write(fd, bootstrap_script)

os.close(fd)

cmd = [py_executable, ez_setup]

else:

cmd = [py_executable, '-c', bootstrap_script]

if unzip and egg_path:

cmd.append('--always-unzip')

env = {}

remove_from_env = ['__PYVENV_LAUNCHER__']

if logger.stdout_level_matches(logger.DEBUG) and egg_path:

cmd.append('-v')

old_chdir = os.getcwd()

if egg_path is not None and os.path.exists(egg_path):

logger.info('Using existing %s egg: %s' % (project_name, egg_path))

cmd.append(egg_path)

if os.environ.get('PYTHONPATH'):

env['PYTHONPATH'] = egg_path + os.path.pathsep + os.environ['PYTHONPATH']

else:

env['PYTHONPATH'] = egg_path

elif tgz_path is not None and os.path.exists(tgz_path):

# Found a tgz source dist, let's chdir

logger.info('Using existing %s egg: %s' % (project_name, tgz_path))

os.chdir(os.path.dirname(tgz_path))

# in this case, we want to be sure that PYTHONPATH is unset (not

# just empty, really unset), else CPython tries to import the

# site.py that it's in virtualenv_support

remove_from_env.append('PYTHONPATH')

elif never_download:

logger.fatal("Can't find any local distributions of %s to install "

"and --never-download is set. Either re-run virtualenv "

"without the --never-download option, or place a %s "

"distribution (%s) in one of these "

"locations: %r" % (project_name, project_name,

egg_path or tgz_path,

search_dirs))

sys.exit(1)

elif egg_path:

logger.info('No %s egg found; downloading' % project_name)

cmd.extend(['--always-copy', '-U', project_name])

else:

logger.info('No %s tgz found; downloading' % project_name)

logger.start_progress('Installing %s...' % project_name)

logger.indent += 2

cwd = None

if project_name == 'distribute':

env['DONT_PATCH_SETUPTOOLS'] = 'true'

def _filter_ez_setup(line):

return filter_ez_setup(line, project_name)

if not os.access(os.getcwd(), os.W_OK):

cwd = tempfile.mkdtemp()

if tgz_path is not None and os.path.exists(tgz_path):

# the current working dir is hostile, let's copy the

# tarball to a temp dir

target = os.path.join(cwd, os.path.split(tgz_path)[-1])

shutil.copy(tgz_path, target)

try:

call_subprocess(cmd, show_stdout=False,

filter_stdout=_filter_ez_setup,

extra_env=env,

remove_from_env=remove_from_env,

cwd=cwd)

finally:

logger.indent -= 2

logger.end_progress()

if cwd is not None:

shutil.rmtree(cwd)

if os.getcwd() != old_chdir:

os.chdir(old_chdir)

if is_jython and os._name == 'nt':

here = os.path.dirname(os.path.abspath(__file__))

dirs = ['.', here,

join(here, 'virtualenv_support')]

if os.path.splitext(os.path.dirname(__file__))[0] != 'virtualenv':

# Probably some boot script; just in case virtualenv is installed...

try:

import virtualenv

except ImportError:

pass

else:

dirs.append(os.path.join(os.path.dirname(virtualenv.__file__), 'virtualenv_support'))

if search_dirs is None:

search_dirs = file_search_dirs()

filenames = []

for dir in search_dirs:

filenames.extend([join(dir, fn) for fn in os.listdir(dir)

if _pip_re.search(fn)])

filenames = [(os.path.basename(filename).lower(), i, filename) for i, filename in enumerate(filenames)]

filenames.sort()

filenames = [filename for basename, i, filename in filenames]

if not filenames:

filename = 'pip'

else:

filename = filenames[-1]

easy_install_script = 'easy_install'

if is_win:

easy_install_script = 'easy_install-script.py'

# There's two subtle issues here when invoking easy_install.

# 1. On unix-like systems the easy_install script can *only* be executed

# directly if its full filesystem path is no longer than 78 characters.

# 2. A work around to [1] is to use the `python path/to/easy_install foo`

# pattern, but that breaks if the path contains non-ASCII characters, as

# you can't put the file encoding declaration before the shebang line.

# The solution is to use Python's -x flag to skip the first line of the

# script (and any ASCII decoding errors that may have occurred in that line)

cmd = [py_executable, '-x', join(os.path.dirname(py_executable), easy_install_script), filename]

# jython and pypy don't yet support -x

if is_jython or is_pypy:

cmd.remove('-x')

if filename == 'pip':

if never_download:

logger.fatal("Can't find any local distributions of pip to install "

"and --never-download is set. Either re-run virtualenv "

"without the --never-download option, or place a pip "

"source distribution (zip/tar.gz/tar.bz2) in one of these "

"locations: %r" % search_dirs)

sys.exit(1)

logger.info('Installing pip from network...')

else:

logger.info('Installing existing %s distribution: %s' % (

os.path.basename(filename), filename))

logger.start_progress('Installing pip...')

logger.indent += 2

def _filter_setup(line):

return filter_ez_setup(line, 'pip')

try:

call_subprocess(cmd, show_stdout=False,

filter_stdout=_filter_setup)

finally:

logger.indent -= 2

if not line.strip():

return Logger.DEBUG

if project_name == 'distribute':

for prefix in ('Extracting', 'Now working', 'Installing', 'Before',

'Scanning', 'Setuptools', 'Egg', 'Already',

'running', 'writing', 'reading', 'installing',

'creating', 'copying', 'byte-compiling', 'removing',

'Processing'):

if line.startswith(prefix):

return Logger.DEBUG

return Logger.DEBUG

for prefix in ['Reading ', 'Best match', 'Processing setuptools',

'Copying setuptools', 'Adding setuptools',

'Installing ', 'Installed ']:

if line.startswith(prefix):

return Logger.DEBUG

"""

def expand_default(self, option):

if self.parser is not None:

self.parser.update_defaults(self.parser.defaults)

"""

def __init__(self, *args, **kwargs):

self.config = ConfigParser.RawConfigParser()

self.files = self.get_config_files()

self.config.read(self.files)

optparse.OptionParser.__init__(self, *args, **kwargs)

def get_config_files(self):

config_file = os.environ.get('VIRTUALENV_CONFIG_FILE', False)

if config_file and os.path.exists(config_file):

return [config_file]

return [default_config_file]

def update_defaults(self, defaults):

"""

# Then go and look for the other sources of configuration:

config = {}

# 1. config files

config.update(dict(self.get_config_section('virtualenv')))

# 2. environmental variables

config.update(dict(self.get_environ_vars()))

# Then set the options with those values

for key, val in config.items():

key = key.replace('_', '-')

if not key.startswith('--'):

key = '--%s' % key # only prefer long opts

option = self.get_option(key)

if option is not None:

# ignore empty values

if not val:

continue

# handle multiline configs

if option.action == 'append':

val = val.split()

else:

option.nargs = 1

if option.action == 'store_false':

val = not strtobool(val)

elif option.action in ('store_true', 'count'):

val = strtobool(val)

try:

val = option.convert_value(key, val)

except optparse.OptionValueError:

e = sys.exc_info()[1]

print("An error occured during configuration: %s" % e)

sys.exit(3)

defaults[option.dest] = val

return defaults

def get_config_section(self, name):

"""

if self.config.has_section(name):

return self.config.items(name)

return []

def get_environ_vars(self, prefix='VIRTUALENV_'):

"""

for key, val in os.environ.items():

if key.startswith(prefix):

yield (key.replace(prefix, '').lower(), val)

def get_default_values(self):

"""

if not self.process_default_values:

# Old, pre-Optik 1.5 behaviour.

return optparse.Values(self.defaults)

defaults = self.update_defaults(self.defaults.copy()) # ours

for option in self._get_all_options():

default = defaults.get(option.dest)

if isinstance(default, basestring):

opt_str = option.get_opt_string()

defaults[option.dest] = option.check_value(opt_str, default)

parser = ConfigOptionParser(

version=virtualenv_version,

usage="%prog [OPTIONS] DEST_DIR",

formatter=UpdatingDefaultsHelpFormatter())

parser.add_option(

'-v', '--verbose',

action='count',

dest='verbose',

default=0,

help="Increase verbosity")

parser.add_option(

'-q', '--quiet',

action='count',

dest='quiet',

default=0,

help='Decrease verbosity')

parser.add_option(

'-p', '--python',

dest='python',

metavar='PYTHON_EXE',

help='The Python interpreter to use, e.g., --python=python2.5 will use the python2.5 '

'interpreter to create the new environment. The default is the interpreter that '

'virtualenv was installed with (%s)' % sys.executable)

parser.add_option(

'--clear',

dest='clear',

action='store_true',

help="Clear out the non-root install and start from scratch")

parser.set_defaults(system_site_packages=False)

parser.add_option(

'--no-site-packages',

dest='system_site_packages',

action='store_false',

help="Don't give access to the global site-packages dir to the "

"virtual environment (default)")

parser.add_option(

'--system-site-packages',

dest='system_site_packages',

action='store_true',

help="Give access to the global site-packages dir to the "

"virtual environment")

parser.add_option(

'--unzip-setuptools',

dest='unzip_setuptools',

action='store_true',

help="Unzip Setuptools or Distribute when installing it")

parser.add_option(

'--relocatable',

dest='relocatable',

action='store_true',

help='Make an EXISTING virtualenv environment relocatable. '

'This fixes up scripts and makes all .pth files relative')

parser.add_option(

'--distribute', '--use-distribute', # the second option is for legacy reasons here. Hi Kenneth!

dest='use_distribute',

action='store_true',

help='Use Distribute instead of Setuptools. Set environ variable '

'VIRTUALENV_DISTRIBUTE to make it the default ')

parser.add_option(

'--no-setuptools',

dest='no_setuptools',

action='store_true',

help='Do not install distribute/setuptools (or pip) '

'in the new virtualenv.')

parser.add_option(

'--no-pip',

dest='no_pip',

action='store_true',

help='Do not install pip in the new virtualenv.')

parser.add_option(

'--setuptools',

dest='use_distribute',

action='store_false',

help='Use Setuptools instead of Distribute. Set environ variable '

'VIRTUALENV_SETUPTOOLS to make it the default ')

# Set this to True to use distribute by default, even in Python 2.

parser.set_defaults(use_distribute=False)

default_search_dirs = file_search_dirs()

parser.add_option(

'--extra-search-dir',

dest="search_dirs",

action="append",

default=default_search_dirs,

help="Directory to look for setuptools/distribute/pip distributions in. "

"You can add any number of additional --extra-search-dir paths.")

parser.add_option(

'--never-download',

dest="never_download",

action="store_true",

help="Never download anything from the network. Instead, virtualenv will fail "

"if local distributions of setuptools/distribute/pip are not present.")

parser.add_option(

'--prompt',

dest='prompt',

help='Provides an alternative prompt prefix for this environment')

if 'extend_parser' in globals():

extend_parser(parser)

options, args = parser.parse_args()

global logger

if 'adjust_options' in globals():

adjust_options(options, args)

verbosity = options.verbose - options.quiet

logger = Logger([(Logger.level_for_integer(2 - verbosity), sys.stdout)])

if options.python and not os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'):

env = os.environ.copy()

interpreter = resolve_interpreter(options.python)

if interpreter == sys.executable:

logger.warn('Already using interpreter %s' % interpreter)

else:

logger.notify('Running virtualenv with interpreter %s' % interpreter)

env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'

file = __file__

if file.endswith('.pyc'):

file = file[:-1]

popen = subprocess.Popen([interpreter, file] + sys.argv[1:], env=env)

raise SystemExit(popen.wait())

# Force --distribute on Python 3, since setuptools is not available.

if majver > 2:

options.use_distribute = True

if os.environ.get('PYTHONDONTWRITEBYTECODE') and not options.use_distribute:

print(

"The PYTHONDONTWRITEBYTECODE environment variable is "

"not compatible with setuptools. Either use --distribute "

"or unset PYTHONDONTWRITEBYTECODE.")

sys.exit(2)

if not args:

print('You must provide a DEST_DIR')

parser.print_help()

sys.exit(2)

if len(args) > 1:

print('There must be only one argument: DEST_DIR (you gave %s)' % (

' '.join(args)))

parser.print_help()

sys.exit(2)

home_dir = args[0]

if os.environ.get('WORKING_ENV'):

logger.fatal('ERROR: you cannot run virtualenv while in a workingenv')

logger.fatal('Please deactivate your workingenv, then re-run this script')

sys.exit(3)

if 'PYTHONHOME' in os.environ:

logger.warn('PYTHONHOME is set. You *must* activate the virtualenv before using it')

del os.environ['PYTHONHOME']

if options.relocatable:

make_environment_relocatable(home_dir)

return

create_environment(home_dir,

site_packages=options.system_site_packages,

clear=options.clear,

unzip_setuptools=options.unzip_setuptools,

use_distribute=options.use_distribute,

prompt=options.prompt,

search_dirs=options.search_dirs,

never_download=options.never_download,

no_setuptools=options.no_setuptools,