mirror of
https://github.com/python/cpython.git
synced 2025-07-30 14:44:10 +00:00
pep8-fied and cleaned up distutils.util
This commit is contained in:
Tarek Ziadé
parent
85bb62872d
commit
3757fbba25
1 changed files with 68 additions and 76 deletions
|
|
@ -12,9 +12,10 @@ from distutils.dep_util import newer
|
|||
from distutils.spawn import spawn
|
||||
from distutils import log
|
||||
|
||||
def get_platform ():
|
||||
"""Return a string that identifies the current platform. This is used
|
||||
mainly to distinguish platform-specific build directories and
|
||||
def get_platform():
|
||||
"""Return a string that identifies the current platform.
|
||||
|
||||
This is used mainly to distinguish platform-specific build directories and
|
||||
platform-specific built distributions. Typically includes the OS name
|
||||
and version and the architecture (as supplied by 'os.uname()'),
|
||||
although the exact information included depends on the OS; eg. for IRIX
|
||||
|
|
@ -39,14 +40,14 @@ def get_platform ():
|
|||
if os.name == 'nt':
|
||||
# sniff sys.version for architecture.
|
||||
prefix = " bit ("
|
||||
i = string.find(sys.version, prefix)
|
||||
i = sys.version.find(prefix)
|
||||
if i == -1:
|
||||
return sys.platform
|
||||
j = string.find(sys.version, ")", i)
|
||||
j = sys.version.find(")", i)
|
||||
look = sys.version[i+len(prefix):j].lower()
|
||||
if look=='amd64':
|
||||
if look == 'amd64':
|
||||
return 'win-amd64'
|
||||
if look=='itanium':
|
||||
if look == 'itanium':
|
||||
return 'win-ia64'
|
||||
return sys.platform
|
||||
|
||||
|
|
@ -61,10 +62,9 @@ def get_platform ():
|
|||
|
||||
# Convert the OS name to lowercase, remove '/' characters
|
||||
# (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
|
||||
osname = string.lower(osname)
|
||||
osname = string.replace(osname, '/', '')
|
||||
machine = string.replace(machine, ' ', '_')
|
||||
machine = string.replace(machine, '/', '-')
|
||||
osname = osname.lower().replace('/', '')
|
||||
machine = machine.replace(' ', '_')
|
||||
machine = machine.replace('/', '-')
|
||||
|
||||
if osname[:5] == "linux":
|
||||
# At least on Linux/Intel, 'machine' is the processor --
|
||||
|
|
@ -154,11 +154,10 @@ def get_platform ():
|
|||
|
||||
return "%s-%s-%s" % (osname, release, machine)
|
||||
|
||||
# get_platform ()
|
||||
|
||||
def convert_path(pathname):
|
||||
"""Return 'pathname' as a name that will work on the native filesystem.
|
||||
|
||||
def convert_path (pathname):
|
||||
"""Return 'pathname' as a name that will work on the native filesystem,
|
||||
i.e. split it on '/' and put it back together again using the current
|
||||
directory separator. Needed because filenames in the setup script are
|
||||
always supplied in Unix style, and have to be converted to the local
|
||||
|
|
@ -171,23 +170,23 @@ def convert_path (pathname):
|
|||
if not pathname:
|
||||
return pathname
|
||||
if pathname[0] == '/':
|
||||
raise ValueError, "path '%s' cannot be absolute" % pathname
|
||||
raise ValueError("path '%s' cannot be absolute" % pathname)
|
||||
if pathname[-1] == '/':
|
||||
raise ValueError, "path '%s' cannot end with '/'" % pathname
|
||||
raise ValueError("path '%s' cannot end with '/'" % pathname)
|
||||
|
||||
paths = string.split(pathname, '/')
|
||||
paths = pathname.split('/')
|
||||
while '.' in paths:
|
||||
paths.remove('.')
|
||||
if not paths:
|
||||
return os.curdir
|
||||
return apply(os.path.join, paths)
|
||||
|
||||
# convert_path ()
|
||||
return os.path.join(*paths)
|
||||
|
||||
|
||||
def change_root (new_root, pathname):
|
||||
"""Return 'pathname' with 'new_root' prepended. If 'pathname' is
|
||||
relative, this is equivalent to "os.path.join(new_root,pathname)".
|
||||
def change_root(new_root, pathname):
|
||||
"""Return 'pathname' with 'new_root' prepended.
|
||||
|
||||
If 'pathname' is relative, this is equivalent to
|
||||
"os.path.join(new_root,pathname)".
|
||||
Otherwise, it requires making 'pathname' relative and then joining the
|
||||
two, which is tricky on DOS/Windows and Mac OS.
|
||||
"""
|
||||
|
|
@ -214,19 +213,20 @@ def change_root (new_root, pathname):
|
|||
return os.path.join(new_root, pathname)
|
||||
else:
|
||||
# Chop off volume name from start of path
|
||||
elements = string.split(pathname, ":", 1)
|
||||
elements = pathname.split(":", 1)
|
||||
pathname = ":" + elements[1]
|
||||
return os.path.join(new_root, pathname)
|
||||
|
||||
else:
|
||||
raise DistutilsPlatformError, \
|
||||
"nothing known about platform '%s'" % os.name
|
||||
|
||||
raise DistutilsPlatformError("nothing known about "
|
||||
"platform '%s'" % os.name)
|
||||
|
||||
_environ_checked = 0
|
||||
def check_environ ():
|
||||
"""Ensure that 'os.environ' has all the environment variables we
|
||||
guarantee that users can use in config files, command-line options,
|
||||
|
||||
def check_environ():
|
||||
"""Ensure that 'os.environ' has all the environment variables needed.
|
||||
|
||||
We guarantee that users can use in config files, command-line options,
|
||||
etc. Currently this includes:
|
||||
HOME - user's home directory (Unix only)
|
||||
PLAT - description of the current platform, including hardware
|
||||
|
|
@ -245,10 +245,10 @@ def check_environ ():
|
|||
|
||||
_environ_checked = 1
|
||||
|
||||
def subst_vars(s, local_vars):
|
||||
"""Perform shell/Perl-style variable substitution on 'string'.
|
||||
|
||||
def subst_vars (s, local_vars):
|
||||
"""Perform shell/Perl-style variable substitution on 'string'. Every
|
||||
occurrence of '$' followed by a name is considered a variable, and
|
||||
Every occurrence of '$' followed by a name is considered a variable, and
|
||||
variable is substituted by the value found in the 'local_vars'
|
||||
dictionary, or in 'os.environ' if it's not in 'local_vars'.
|
||||
'os.environ' is first checked/augmented to guarantee that it contains
|
||||
|
|
@ -266,14 +266,13 @@ def subst_vars (s, local_vars):
|
|||
try:
|
||||
return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
|
||||
except KeyError, var:
|
||||
raise ValueError, "invalid variable '$%s'" % var
|
||||
raise ValueError("invalid variable '$%s'" % var)
|
||||
|
||||
# subst_vars ()
|
||||
def grok_environment_error(exc, prefix="error: "):
|
||||
"""Generate a useful error message from an EnvironmentError.
|
||||
|
||||
|
||||
def grok_environment_error (exc, prefix="error: "):
|
||||
"""Generate a useful error message from an EnvironmentError (IOError or
|
||||
OSError) exception object. Handles Python 1.5.1 and 1.5.2 styles, and
|
||||
This will generate an IOError or an OSError exception object.
|
||||
Handles Python 1.5.1 and 1.5.2 styles, and
|
||||
does what it can to deal with exception objects that don't have a
|
||||
filename (which happens when the error is due to a two-file operation,
|
||||
such as 'rename()' or 'link()'. Returns the error message as a string
|
||||
|
|
@ -292,18 +291,20 @@ def grok_environment_error (exc, prefix="error: "):
|
|||
|
||||
return error
|
||||
|
||||
|
||||
# Needed by 'split_quoted()'
|
||||
_wordchars_re = _squote_re = _dquote_re = None
|
||||
|
||||
def _init_regex():
|
||||
global _wordchars_re, _squote_re, _dquote_re
|
||||
_wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
|
||||
_squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
|
||||
_dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')
|
||||
|
||||
def split_quoted (s):
|
||||
def split_quoted(s):
|
||||
"""Split a string up according to Unix shell-like rules for quotes and
|
||||
backslashes. In short: words are delimited by spaces, as long as those
|
||||
backslashes.
|
||||
|
||||
In short: words are delimited by spaces, as long as those
|
||||
spaces are not escaped by a backslash, or inside a quoted string.
|
||||
Single and double quotes are equivalent, and the quote characters can
|
||||
be backslash-escaped. The backslash is stripped from any two-character
|
||||
|
|
@ -311,13 +312,12 @@ def split_quoted (s):
|
|||
characters are stripped from any quoted string. Returns a list of
|
||||
words.
|
||||
"""
|
||||
|
||||
# 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 = string.strip(s)
|
||||
s = s.strip()
|
||||
words = []
|
||||
pos = 0
|
||||
|
||||
|
|
@ -330,7 +330,7 @@ def split_quoted (s):
|
|||
|
||||
if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
|
||||
words.append(s[:end]) # we definitely have a word delimiter
|
||||
s = string.lstrip(s[end:])
|
||||
s = s[end:].lstrip()
|
||||
pos = 0
|
||||
|
||||
elif s[end] == '\\': # preserve whatever is being escaped;
|
||||
|
|
@ -344,12 +344,11 @@ def split_quoted (s):
|
|||
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]
|
||||
raise RuntimeError("this can't happen "
|
||||
"(bad char '%c')" % s[end])
|
||||
|
||||
if m is None:
|
||||
raise ValueError, \
|
||||
"bad string (mismatched %s quotes?)" % s[end]
|
||||
raise ValueError("bad string (mismatched %s quotes?)" % s[end])
|
||||
|
||||
(beg, end) = m.span()
|
||||
s = s[:beg] + s[beg+1:end-1] + s[end:]
|
||||
|
|
@ -361,13 +360,12 @@ def split_quoted (s):
|
|||
|
||||
return words
|
||||
|
||||
# split_quoted ()
|
||||
|
||||
def execute(func, args, msg=None, verbose=0, dry_run=0):
|
||||
"""Perform some action that affects the outside world.
|
||||
|
||||
def execute (func, args, msg=None, verbose=0, dry_run=0):
|
||||
"""Perform some action that affects the outside world (eg. by
|
||||
writing to the filesystem). Such actions are special because they
|
||||
are disabled by the 'dry_run' flag. This method takes care of all
|
||||
eg. by writing to the filesystem). Such actions are special because
|
||||
they are disabled by the 'dry_run' flag. This method takes care of all
|
||||
that bureaucracy for you; all you have to do is supply the
|
||||
function to call and an argument tuple for it (to embody the
|
||||
"external action" being performed), and an optional message to
|
||||
|
|
@ -380,17 +378,17 @@ def execute (func, args, msg=None, verbose=0, dry_run=0):
|
|||
|
||||
log.info(msg)
|
||||
if not dry_run:
|
||||
apply(func, args)
|
||||
func(*args)
|
||||
|
||||
|
||||
def strtobool (val):
|
||||
def strtobool(val):
|
||||
"""Convert a string representation of truth to true (1) or false (0).
|
||||
|
||||
True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
|
||||
are 'n', 'no', 'f', 'false', 'off', and '0'. Raises ValueError if
|
||||
'val' is anything else.
|
||||
"""
|
||||
val = string.lower(val)
|
||||
val = val.lower()
|
||||
if val in ('y', 'yes', 't', 'true', 'on', '1'):
|
||||
return 1
|
||||
elif val in ('n', 'no', 'f', 'false', 'off', '0'):
|
||||
|
|
@ -399,15 +397,13 @@ def strtobool (val):
|
|||
raise ValueError, "invalid truth value %r" % (val,)
|
||||
|
||||
|
||||
def byte_compile (py_files,
|
||||
optimize=0, force=0,
|
||||
prefix=None, base_dir=None,
|
||||
verbose=1, dry_run=0,
|
||||
direct=None):
|
||||
def byte_compile(py_files, optimize=0, force=0, prefix=None, base_dir=None,
|
||||
verbose=1, dry_run=0, direct=None):
|
||||
"""Byte-compile a collection of Python source files to either .pyc
|
||||
or .pyo files in the same directory. 'py_files' is a list of files
|
||||
to compile; any files that don't end in ".py" are silently skipped.
|
||||
'optimize' must be one of the following:
|
||||
or .pyo files in the same directory.
|
||||
|
||||
'py_files' is a list of files to compile; any files that don't end in
|
||||
".py" are silently skipped. 'optimize' must be one of the following:
|
||||
0 - don't optimize (generate .pyc)
|
||||
1 - normal optimization (like "python -O")
|
||||
2 - extra optimization (like "python -OO")
|
||||
|
|
@ -432,7 +428,6 @@ def byte_compile (py_files,
|
|||
generated in indirect mode; unless you know what you're doing, leave
|
||||
it set to None.
|
||||
"""
|
||||
|
||||
# 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
|
||||
|
|
@ -481,7 +476,7 @@ files = [
|
|||
#if prefix:
|
||||
# prefix = os.path.abspath(prefix)
|
||||
|
||||
script.write(string.join(map(repr, py_files), ",\n") + "]\n")
|
||||
script.write(",\n".join(map(repr, py_files)) + "]\n")
|
||||
script.write("""
|
||||
byte_compile(files, optimize=%r, force=%r,
|
||||
prefix=%r, base_dir=%r,
|
||||
|
|
@ -520,9 +515,8 @@ byte_compile(files, optimize=%r, force=%r,
|
|||
dfile = file
|
||||
if prefix:
|
||||
if file[:len(prefix)] != prefix:
|
||||
raise ValueError, \
|
||||
("invalid prefix: filename %r doesn't start with %r"
|
||||
% (file, 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)
|
||||
|
|
@ -537,13 +531,11 @@ byte_compile(files, optimize=%r, force=%r,
|
|||
log.debug("skipping byte-compilation of %s to %s",
|
||||
file, cfile_base)
|
||||
|
||||
# byte_compile ()
|
||||
|
||||
def rfc822_escape (header):
|
||||
def rfc822_escape(header):
|
||||
"""Return a version of the string escaped for inclusion in an
|
||||
RFC-822 header, by ensuring there are 8 spaces space after each newline.
|
||||
"""
|
||||
lines = string.split(header, '\n')
|
||||
lines = map(string.strip, lines)
|
||||
header = string.join(lines, '\n' + 8*' ')
|
||||
return header
|
||||
lines = [x.strip() for x in header.split('\n')]
|
||||
sep = '\n' + 8*' '
|
||||
return sep.join(lines)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue