# file dependencies

'newer', 'newer_group',

# helpers for commands (dry-run system)

'execute', 'write_file',

# spawning programs

'find_executable', 'spawn',

# path manipulation

'convert_path', 'change_root',

# 2to3 conversion

'Mixin2to3', 'run_2to3',

# packaging compatibility helpers

'cfg_to_args', 'generate_setup_py',

'egginfo_to_distinfo',

'get_install_method',

# misc

'ask', 'check_environ', 'encode_multipart', 'resolve_name',

# querying for information TODO move to sysconfig

'get_compiler_versions', 'get_platform', 'set_platform',

# configuration TODO move to packaging.config

'get_pypirc_path', 'read_pypirc', 'generate_pypirc',

'strtobool', 'split_multiline',

"""Tell if the target is newer than the source.

if not os.path.exists(source):

raise PackagingFileError("file '%s' does not exist" %

os.path.abspath(source))

if not os.path.exists(target):

return True

"""Return a string that identifies the current platform.

global _PLATFORM

if _PLATFORM is None:

_PLATFORM = sysconfig.get_platform()

"""Set the platform string identifier returned by get_platform().

global _PLATFORM

"""Return 'pathname' as a name that will work on the native filesystem.

if os.sep == '/':

return pathname

if not pathname:

return pathname

if pathname[0] == '/':

raise ValueError("path '%s' cannot be absolute" % pathname)

if pathname[-1] == '/':

raise ValueError("path '%s' cannot end with '/'" % pathname)

paths = pathname.split('/')

while os.curdir in paths:

paths.remove(os.curdir)

if not paths:

return os.curdir

"""Return 'pathname' with 'new_root' prepended.

if os.name == 'posix':

if not os.path.isabs(pathname):

return os.path.join(new_root, pathname)

else:

return os.path.join(new_root, pathname[1:])

elif os.name == 'nt':

drive, path = os.path.splitdrive(pathname)

if path[0] == '\\':

path = path[1:]

return os.path.join(new_root, path)

elif os.name == 'os2':

drive, path = os.path.splitdrive(pathname)

if path[0] == os.sep:

path = path[1:]

return os.path.join(new_root, path)

else:

raise PackagingPlatformError("nothing known about "

"""Ensure that 'os.environ' has all the environment variables needed.

global _environ_checked

if _environ_checked:

return

if os.name == 'posix' and 'HOME' not in os.environ:

import pwd

os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]

if 'PLAT' not in os.environ:

os.environ['PLAT'] = sysconfig.get_platform()

global _wordchars_re, _squote_re, _dquote_re

_wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)

_squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")

"""Split a string up according to Unix shell-like rules for quotes and

# This is a nice algorithm for splitting up a single string, since it

# doesn't require character-by-character examination. It was a little

# bit of a brain-bender to get it working right, though...

if _wordchars_re is None:

_init_regex()

s = s.strip()

words = []

pos = 0

while s:

m = _wordchars_re.match(s, pos)

end = m.end()

if end == len(s):

words.append(s[:end])

break

if s[end] in string.whitespace: # unescaped, unquoted whitespace: now

words.append(s[:end]) # we definitely have a word delimiter

s = s[end:].lstrip()

pos = 0

elif s[end] == '\\': # preserve whatever is being escaped;

# will become part of the current word

s = s[:end] + s[end + 1:]

pos = end + 1

else:

if s[end] == "'": # slurp singly-quoted string

m = _squote_re.match(s, end)

elif s[end] == '"': # slurp doubly-quoted string

m = _dquote_re.match(s, end)

else:

raise RuntimeError("this can't happen "

"(bad char '%c')" % s[end])

if m is None:

raise ValueError("bad string (mismatched %s quotes?)" % s[end])

beg, end = m.span()

s = s[:beg] + s[beg + 1:end - 1] + s[end:]

pos = m.end() - 2

if pos >= len(s):

words.append(s)

break

"""Split a multiline string into a list, excluding blank lines."""

return [element for element in

(line.strip() for line in value.split('\n'))

"""Perform some action that affects the outside world.

if msg is None:

msg = "%s%r" % (func.__name__, args)

if msg[-2:] == ',)': # correct for singleton tuple

msg = msg[0:-2] + ')'

logger.info(msg)

if not dry_run:

"""Convert a string representation of truth to a boolean.

val = val.lower()

if val in ('y', 'yes', 't', 'true', 'on', '1'):

return True

elif val in ('n', 'no', 'f', 'false', 'off', '0'):

return False

else:

base_dir=None, dry_run=False, direct=None):

"""Byte-compile a collection of Python source files to either .pyc

# FIXME use compileall + remove direct/indirect shenanigans

# First, if the caller didn't force us into direct or indirect mode,

# figure out which mode we should be in. We take a conservative

# approach: choose direct mode *only* if the current interpreter is

# in debug mode and optimize is 0. If we're not in debug mode (-O

# or -OO), we don't know which level of optimization this

# interpreter is running with, so we can't do direct

# byte-compilation and be certain that it's the right thing. Thus,

# always compile indirectly if the current interpreter is in either

# optimize mode, or if either optimization level was requested by

# the caller.

if direct is None:

direct = (__debug__ and optimize == 0)

# "Indirect" byte-compilation: write a temporary script and then

# run it with the appropriate flags.

if not direct:

from tempfile import mkstemp

# XXX use something better than mkstemp

script_fd, script_name = mkstemp(".py")

os.close(script_fd)

script_fd = None

logger.info("writing byte-compilation script '%s'", script_name)

if not dry_run:

if script_fd is not None:

script = os.fdopen(script_fd, "w", encoding='utf-8')

else:

script = open(script_name, "w", encoding='utf-8')

with script:

script.write("""\

""")

# XXX would be nice to write absolute filenames, just for

# safety's sake (script should be more robust in the face of

# chdir'ing before running it). But this requires abspath'ing

# 'prefix' as well, and that breaks the hack in build_lib's

# 'byte_compile()' method that carefully tacks on a trailing

# slash (os.sep really) to make sure the prefix here is "just

# right". This whole prefix business is rather delicate -- the

# problem is that it's really a directory, but I'm treating it

# as a dumb string, so trailing slashes and so forth matter.

#py_files = map(os.path.abspath, py_files)

#if prefix:

# prefix = os.path.abspath(prefix)

script.write(",\n".join(map(repr, py_files)) + "]\n")

script.write("""

""" % (optimize, force, prefix, base_dir))

cmd = [sys.executable, script_name]

env = os.environ.copy()

env['PYTHONPATH'] = os.path.pathsep.join(sys.path)

try:

spawn(cmd, env=env)

finally:

execute(os.remove, (script_name,), "removing %s" % script_name,

dry_run=dry_run)

# "Direct" byte-compilation: use the py_compile module to compile

# right here, right now. Note that the script generated in indirect

# mode simply calls 'byte_compile()' in direct mode, a weird sort of

# cross-process recursion. Hey, it works!

else:

from py_compile import compile

for file in py_files:

if file[-3:] != ".py":

# This lets us be lazy and not filter filenames in

# the "install_lib" command.

continue

# Terminology from the py_compile module:

# cfile - byte-compiled file

# dfile - purported source filename (same as 'file' by default)

# The second argument to cache_from_source forces the extension to

# be .pyc (if true) or .pyo (if false); without it, the extension

# would depend on the calling Python's -O option

cfile = imp.cache_from_source(file, not optimize)

dfile = file

if prefix:

if file[:len(prefix)] != prefix:

raise ValueError("invalid prefix: filename %r doesn't "

"start with %r" % (file, prefix))

dfile = dfile[len(prefix):]

if base_dir:

dfile = os.path.join(base_dir, dfile)

cfile_base = os.path.basename(cfile)

if direct:

if force or newer(file, cfile):

logger.info("byte-compiling %s to %s", file, cfile_base)

if not dry_run:

compile(file, cfile, dfile)

else:

logger.debug("skipping byte-compilation of %s to %s",

"""Find the ld version. The version scheme differs under Mac OS X."""

if sys.platform == 'darwin':

return _find_exe_version('ld -v', _MAC_OS_X_LD_VERSION)

else:

"""Find the version of an executable by running `cmd` in the shell.

from subprocess import Popen, PIPE

executable = cmd.split()[0]

if find_executable(executable) is None:

return None

pipe = Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE)

try:

stdout, stderr = pipe.communicate()

finally:

pipe.stdout.close()

pipe.stderr.close()

# some commands like ld under MacOS X, will give the

# output in the stderr, rather than stdout.

if stdout != '':

out_string = stdout

else:

out_string = stderr

result = pattern.search(out_string)

if result is None:

return None

"""Return a tuple providing the versions of gcc, ld and dllwrap

gcc = _find_exe_version('gcc -dumpversion')

ld = _find_ld_version()

dllwrap = _find_exe_version('dllwrap --version')

"""Return true if 'target' is out-of-date with respect to any file

# If the target doesn't even exist, then it's definitely out-of-date.

if not os.path.exists(target):

return True

# Otherwise we have to find out the hard way: if *any* source file

# is more recent than 'target', then 'target' is out-of-date and

# we can immediately return true. If we fall through to the end

# of the loop, then 'target' is up-to-date and we return false.

target_mtime = os.stat(target).st_mtime

for source in sources:

if not os.path.exists(source):

if missing == 'error': # blow up when we stat() the file

pass

elif missing == 'ignore': # missing source dropped from

continue # target's dependency list

elif missing == 'newer': # missing source means target is

return True # out-of-date

if os.stat(source).st_mtime > target_mtime:

return True

"""Create *filename* and write *contents* to it.

with open(filename, "w") as f:

for line in contents:

# XXX use os.path

path = path.split(os.sep)

root = root.split(os.sep)

if len(root) > len(path):

return False

for pos, part in enumerate(root):

if path[pos] != part:

return False

# Return a dotted package name, given a subpath

if not _under(path, root_path):

raise ValueError('"%s" is not a subpath of "%s"' % (path, root_path))

"""Return a list all Python packages found recursively within

packages = []

discarded = []

def _discarded(path):

for discard in discarded:

if _under(path, discard):

return True

return False

for path in paths:

path = convert_path(path)

for root, dirs, files in os.walk(path):

for dir_ in dirs:

fullpath = os.path.join(root, dir_)

if _discarded(fullpath):

continue

# we work only with Python packages

if not _is_package(fullpath):

discarded.append(fullpath)

continue

# see if it's excluded

excluded = False

package_name = _package_name(path, fullpath)

for pattern in exclude:

if fnmatchcase(package_name, pattern):

excluded = True

break

if excluded:

continue

# adding it to the list

packages.append(package_name)

"""Resolve a name like ``module.object`` to an object and return it.

if '.' not in name:

# shortcut

__import__(name)

return sys.modules[name]

# FIXME clean up this code!

parts = name.split('.')

cursor = len(parts)

module_name = parts[:cursor]

ret = ''

while cursor > 0:

try:

ret = __import__('.'.join(module_name))

break

except ImportError:

cursor -= 1

module_name = parts[:cursor]

if ret == '':

raise ImportError(parts[0])

for part in parts[1:]:

try:

ret = getattr(ret, part)

except AttributeError as exc:

raise ImportError(exc)

"""Like os.path.splitext, but take off .tar too"""

base, ext = posixpath.splitext(path)

if base.lower().endswith('.tar'):

ext = base[-4:] + ext

base = base[:-4]

"""Run another program specified as a command list 'cmd' in a new process.

logger.debug('spawn: running %r', cmd)

if dry_run:

logger.debug('dry run, no process actually spawned')

return

if sys.platform == 'darwin':

global _cfg_target, _cfg_target_split

if _cfg_target is None:

_cfg_target = sysconfig.get_config_var(

'MACOSX_DEPLOYMENT_TARGET') or ''

if _cfg_target:

_cfg_target_split = [int(x) for x in _cfg_target.split('.')]

if _cfg_target:

# ensure that the deployment target of build process is not less

# than that used when the interpreter was built. This ensures

# extension modules are built with correct compatibility values

env = env or os.environ

cur_target = env.get('MACOSX_DEPLOYMENT_TARGET', _cfg_target)

if _cfg_target_split > [int(x) for x in cur_target.split('.')]:

my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '

'now "%s" but "%s" during configure'

% (cur_target, _cfg_target))

raise PackagingPlatformError(my_msg)

env = dict(env, MACOSX_DEPLOYMENT_TARGET=cur_target)

exit_status = subprocess.call(cmd, env=env)

if exit_status != 0:

msg = "command %r failed with exit status %d"

"""Try to find 'executable' in the directories listed in 'path'.

if path is None:

path = os.environ['PATH']

paths = path.split(os.pathsep)

base, ext = os.path.splitext(executable)

if (sys.platform == 'win32' or os.name == 'os2') and (ext != '.exe'):

executable = executable + '.exe'

if not os.path.isfile(executable):

for p in paths:

f = os.path.join(p, executable)

if os.path.isfile(f):

# the file exists, we have a shot at spawn working

return f

return None

else:

"""Create a default .pypirc file."""

rc = get_pypirc_path()

with open(rc, 'w') as f:

f.write(DEFAULT_PYPIRC % (username, password))

try:

os.chmod(rc, 0o600)

except OSError:

# should do something better here

"""Read the .pypirc file."""

rc = get_pypirc_path()

if os.path.exists(rc):

config = RawConfigParser()

config.read(rc)

sections = config.sections()

if 'distutils' in sections:

# let's get the list of servers

index_servers = config.get('distutils', 'index-servers')

_servers = [server.strip() for server in

index_servers.split('\n')

if server.strip() != '']

if _servers == []:

# nothing set, let's try to get the default pypi

if 'pypi' in sections:

_servers = ['pypi']

else:

# the file is not properly defined, returning

# an empty dict

return {}

for server in _servers:

current = {'server': server}

current['username'] = config.get(server, 'username')

# optional params

for key, default in (('repository', DEFAULT_REPOSITORY),

('realm', DEFAULT_REALM),

('password', None)):

if config.has_option(server, key):

current[key] = config.get(server, key)

else:

current[key] = default

if (current['server'] == repository or

current['repository'] == repository):

return current

elif 'server-login' in sections:

# old format

server = 'server-login'

if config.has_option(server, 'repository'):

repository = config.get(server, 'repository')

else:

repository = DEFAULT_REPOSITORY

return {'username': config.get(server, 'username'),

'password': config.get(server, 'password'),

'repository': repository,

'server': server,

'realm': DEFAULT_REALM}

options=None, explicit=None):

""" Wrapper function around the refactor() class which

#if not files:

# return

# Make this class local, to delay import of 2to3

from lib2to3.refactor import get_fixers_from_package, RefactoringTool

fixers = get_fixers_from_package('lib2to3.fixes')

if fixer_names:

for fixername in fixer_names:

fixers.extend(get_fixers_from_package(fixername))

r = RefactoringTool(fixers, options=options)

""" Wrapper class for commands that run 2to3.

# list of fixers to run; defaults to all implicit from lib2to3.fixers

fixer_names = None

# dict of options

options = None

# list of extra fixers to invoke

explicit = None

# TODO need a better way to add just one fixer from a package

# TODO need a way to exclude individual fixers

def run_2to3(self, files, doctests_only=False):

""" Issues a call to util.run_2to3. """

return run_2to3(files, doctests_only, self.fixer_names,

self.options, self.explicit)

"""Extended globbing function that supports ** and {opt1,opt2,opt3}."""

if _CHECK_RECURSIVE_GLOB.search(path_glob):

msg = """invalid glob %r: recursive glob "**" must be used alone"""

raise ValueError(msg % path_glob)

if _CHECK_MISMATCH_SET.search(path_glob):

msg = """invalid glob %r: mismatching set marker '{' or '}'"""

raise ValueError(msg % path_glob)

rich_path_glob = RICH_GLOB.split(path_glob, 1)

if len(rich_path_glob) > 1:

assert len(rich_path_glob) == 3, rich_path_glob

prefix, set, suffix = rich_path_glob

for item in set.split(','):

for path in _iglob(''.join((prefix, item, suffix))):

yield path

else:

if '**' not in path_glob:

for item in std_iglob(path_glob):

yield item

else:

prefix, radical = path_glob.split('**', 1)

if prefix == '':

prefix = '.'

if radical == '':

radical = '*'

else:

# we support both

radical = radical.lstrip('/')

radical = radical.lstrip('\\')

for path, dir, files in os.walk(prefix):

path = os.path.normpath(path)

for file in _iglob(os.path.join(path, radical)):

"""Compatibility helper to use setup.cfg in setup.py.

# XXX ** == needs testing

D1_D2_SETUP_ARGS = {"name": ("metadata",),

"version": ("metadata",),

"author": ("metadata",),

"author_email": ("metadata",),

"maintainer": ("metadata",),

"maintainer_email": ("metadata",),

"url": ("metadata", "home_page"),

"description": ("metadata", "summary"),

"long_description": ("metadata", "description"),

"download-url": ("metadata",),

"classifiers": ("metadata", "classifier"),

"platforms": ("metadata", "platform"), # **

"license": ("metadata",),

"requires": ("metadata", "requires_dist"),

"provides": ("metadata", "provides_dist"), # **

"obsoletes": ("metadata", "obsoletes_dist"), # **

"package_dir": ("files", 'packages_root'),

"packages": ("files",),

"scripts": ("files",),

"py_modules": ("files", "modules"), # **

}

MULTI_FIELDS = ("classifiers",

"platforms",

"requires",

"provides",

"obsoletes",

"packages",

"scripts",

"py_modules")

def has_get_option(config, section, option):

if config.has_option(section, option):

return config.get(section, option)

elif config.has_option(section, option.replace('_', '-')):

return config.get(section, option.replace('_', '-'))

else:

return False