AppPkg/Applications/Python/Python-2.7.10: Initial Checkin part 5/5.
These files are candidates for modification during the port to EDK II. The following files were copied, unchanged, from the Python 2.7.2 port. Ia32/pyconfig.h X64/pyconfig.h PyMod-2.7.10/Modules/config.c PyMod-2.7.10/Modules/edk2module.c Py2710ReadMe.txt // Copied from PythonReadMe.txt Python2710.inf // Copied from PythonCore.inf The remaining files were copied, unchanged, from the cPython 2.7.10 distribution. These files are unchanged and set the baseline for subsequent commits. Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: Daryl McDaniel <edk2-lists@mc2research.org> git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@18741 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
committed by
darylm503
parent
3257aa9932
commit
3ec97ca490
@@ -0,0 +1,550 @@
|
||||
# Module 'ntpath' -- common operations on WinNT/Win95 pathnames
|
||||
"""Common pathname manipulations, WindowsNT/95 version.
|
||||
|
||||
Instead of importing this module directly, import os and refer to this
|
||||
module as os.path.
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import stat
|
||||
import genericpath
|
||||
import warnings
|
||||
|
||||
from genericpath import *
|
||||
from genericpath import _unicode
|
||||
|
||||
__all__ = ["normcase","isabs","join","splitdrive","split","splitext",
|
||||
"basename","dirname","commonprefix","getsize","getmtime",
|
||||
"getatime","getctime", "islink","exists","lexists","isdir","isfile",
|
||||
"ismount","walk","expanduser","expandvars","normpath","abspath",
|
||||
"splitunc","curdir","pardir","sep","pathsep","defpath","altsep",
|
||||
"extsep","devnull","realpath","supports_unicode_filenames","relpath"]
|
||||
|
||||
# strings representing various path-related bits and pieces
|
||||
curdir = '.'
|
||||
pardir = '..'
|
||||
extsep = '.'
|
||||
sep = '\\'
|
||||
pathsep = ';'
|
||||
altsep = '/'
|
||||
defpath = '.;C:\\bin'
|
||||
if 'ce' in sys.builtin_module_names:
|
||||
defpath = '\\Windows'
|
||||
elif 'os2' in sys.builtin_module_names:
|
||||
# OS/2 w/ VACPP
|
||||
altsep = '/'
|
||||
devnull = 'nul'
|
||||
|
||||
# Normalize the case of a pathname and map slashes to backslashes.
|
||||
# Other normalizations (such as optimizing '../' away) are not done
|
||||
# (this is done by normpath).
|
||||
|
||||
def normcase(s):
|
||||
"""Normalize case of pathname.
|
||||
|
||||
Makes all characters lowercase and all slashes into backslashes."""
|
||||
return s.replace("/", "\\").lower()
|
||||
|
||||
|
||||
# Return whether a path is absolute.
|
||||
# Trivial in Posix, harder on the Mac or MS-DOS.
|
||||
# For DOS it is absolute if it starts with a slash or backslash (current
|
||||
# volume), or if a pathname after the volume letter and colon / UNC resource
|
||||
# starts with a slash or backslash.
|
||||
|
||||
def isabs(s):
|
||||
"""Test whether a path is absolute"""
|
||||
s = splitdrive(s)[1]
|
||||
return s != '' and s[:1] in '/\\'
|
||||
|
||||
|
||||
# Join two (or more) paths.
|
||||
def join(path, *paths):
|
||||
"""Join two or more pathname components, inserting "\\" as needed."""
|
||||
result_drive, result_path = splitdrive(path)
|
||||
for p in paths:
|
||||
p_drive, p_path = splitdrive(p)
|
||||
if p_path and p_path[0] in '\\/':
|
||||
# Second path is absolute
|
||||
if p_drive or not result_drive:
|
||||
result_drive = p_drive
|
||||
result_path = p_path
|
||||
continue
|
||||
elif p_drive and p_drive != result_drive:
|
||||
if p_drive.lower() != result_drive.lower():
|
||||
# Different drives => ignore the first path entirely
|
||||
result_drive = p_drive
|
||||
result_path = p_path
|
||||
continue
|
||||
# Same drive in different case
|
||||
result_drive = p_drive
|
||||
# Second path is relative to the first
|
||||
if result_path and result_path[-1] not in '\\/':
|
||||
result_path = result_path + '\\'
|
||||
result_path = result_path + p_path
|
||||
## add separator between UNC and non-absolute path
|
||||
if (result_path and result_path[0] not in '\\/' and
|
||||
result_drive and result_drive[-1:] != ':'):
|
||||
return result_drive + sep + result_path
|
||||
return result_drive + result_path
|
||||
|
||||
|
||||
# Split a path in a drive specification (a drive letter followed by a
|
||||
# colon) and the path specification.
|
||||
# It is always true that drivespec + pathspec == p
|
||||
def splitdrive(p):
|
||||
"""Split a pathname into drive/UNC sharepoint and relative path specifiers.
|
||||
Returns a 2-tuple (drive_or_unc, path); either part may be empty.
|
||||
|
||||
If you assign
|
||||
result = splitdrive(p)
|
||||
It is always true that:
|
||||
result[0] + result[1] == p
|
||||
|
||||
If the path contained a drive letter, drive_or_unc will contain everything
|
||||
up to and including the colon. e.g. splitdrive("c:/dir") returns ("c:", "/dir")
|
||||
|
||||
If the path contained a UNC path, the drive_or_unc will contain the host name
|
||||
and share up to but not including the fourth directory separator character.
|
||||
e.g. splitdrive("//host/computer/dir") returns ("//host/computer", "/dir")
|
||||
|
||||
Paths cannot contain both a drive letter and a UNC path.
|
||||
|
||||
"""
|
||||
if len(p) > 1:
|
||||
normp = p.replace(altsep, sep)
|
||||
if (normp[0:2] == sep*2) and (normp[2:3] != sep):
|
||||
# is a UNC path:
|
||||
# vvvvvvvvvvvvvvvvvvvv drive letter or UNC path
|
||||
# \\machine\mountpoint\directory\etc\...
|
||||
# directory ^^^^^^^^^^^^^^^
|
||||
index = normp.find(sep, 2)
|
||||
if index == -1:
|
||||
return '', p
|
||||
index2 = normp.find(sep, index + 1)
|
||||
# a UNC path can't have two slashes in a row
|
||||
# (after the initial two)
|
||||
if index2 == index + 1:
|
||||
return '', p
|
||||
if index2 == -1:
|
||||
index2 = len(p)
|
||||
return p[:index2], p[index2:]
|
||||
if normp[1] == ':':
|
||||
return p[:2], p[2:]
|
||||
return '', p
|
||||
|
||||
# Parse UNC paths
|
||||
def splitunc(p):
|
||||
"""Split a pathname into UNC mount point and relative path specifiers.
|
||||
|
||||
Return a 2-tuple (unc, rest); either part may be empty.
|
||||
If unc is not empty, it has the form '//host/mount' (or similar
|
||||
using backslashes). unc+rest is always the input path.
|
||||
Paths containing drive letters never have an UNC part.
|
||||
"""
|
||||
if p[1:2] == ':':
|
||||
return '', p # Drive letter present
|
||||
firstTwo = p[0:2]
|
||||
if firstTwo == '//' or firstTwo == '\\\\':
|
||||
# is a UNC path:
|
||||
# vvvvvvvvvvvvvvvvvvvv equivalent to drive letter
|
||||
# \\machine\mountpoint\directories...
|
||||
# directory ^^^^^^^^^^^^^^^
|
||||
normp = p.replace('\\', '/')
|
||||
index = normp.find('/', 2)
|
||||
if index <= 2:
|
||||
return '', p
|
||||
index2 = normp.find('/', index + 1)
|
||||
# a UNC path can't have two slashes in a row
|
||||
# (after the initial two)
|
||||
if index2 == index + 1:
|
||||
return '', p
|
||||
if index2 == -1:
|
||||
index2 = len(p)
|
||||
return p[:index2], p[index2:]
|
||||
return '', p
|
||||
|
||||
|
||||
# Split a path in head (everything up to the last '/') and tail (the
|
||||
# rest). After the trailing '/' is stripped, the invariant
|
||||
# join(head, tail) == p holds.
|
||||
# The resulting head won't end in '/' unless it is the root.
|
||||
|
||||
def split(p):
|
||||
"""Split a pathname.
|
||||
|
||||
Return tuple (head, tail) where tail is everything after the final slash.
|
||||
Either part may be empty."""
|
||||
|
||||
d, p = splitdrive(p)
|
||||
# set i to index beyond p's last slash
|
||||
i = len(p)
|
||||
while i and p[i-1] not in '/\\':
|
||||
i = i - 1
|
||||
head, tail = p[:i], p[i:] # now tail has no slashes
|
||||
# remove trailing slashes from head, unless it's all slashes
|
||||
head2 = head
|
||||
while head2 and head2[-1] in '/\\':
|
||||
head2 = head2[:-1]
|
||||
head = head2 or head
|
||||
return d + head, tail
|
||||
|
||||
|
||||
# Split a path in root and extension.
|
||||
# The extension is everything starting at the last dot in the last
|
||||
# pathname component; the root is everything before that.
|
||||
# It is always true that root + ext == p.
|
||||
|
||||
def splitext(p):
|
||||
return genericpath._splitext(p, sep, altsep, extsep)
|
||||
splitext.__doc__ = genericpath._splitext.__doc__
|
||||
|
||||
|
||||
# Return the tail (basename) part of a path.
|
||||
|
||||
def basename(p):
|
||||
"""Returns the final component of a pathname"""
|
||||
return split(p)[1]
|
||||
|
||||
|
||||
# Return the head (dirname) part of a path.
|
||||
|
||||
def dirname(p):
|
||||
"""Returns the directory component of a pathname"""
|
||||
return split(p)[0]
|
||||
|
||||
# Is a path a symbolic link?
|
||||
# This will always return false on systems where posix.lstat doesn't exist.
|
||||
|
||||
def islink(path):
|
||||
"""Test for symbolic link.
|
||||
On WindowsNT/95 and OS/2 always returns false
|
||||
"""
|
||||
return False
|
||||
|
||||
# alias exists to lexists
|
||||
lexists = exists
|
||||
|
||||
# Is a path a mount point? Either a root (with or without drive letter)
|
||||
# or an UNC path with at most a / or \ after the mount point.
|
||||
|
||||
def ismount(path):
|
||||
"""Test whether a path is a mount point (defined as root of drive)"""
|
||||
unc, rest = splitunc(path)
|
||||
if unc:
|
||||
return rest in ("", "/", "\\")
|
||||
p = splitdrive(path)[1]
|
||||
return len(p) == 1 and p[0] in '/\\'
|
||||
|
||||
|
||||
# Directory tree walk.
|
||||
# For each directory under top (including top itself, but excluding
|
||||
# '.' and '..'), func(arg, dirname, filenames) is called, where
|
||||
# dirname is the name of the directory and filenames is the list
|
||||
# of files (and subdirectories etc.) in the directory.
|
||||
# The func may modify the filenames list, to implement a filter,
|
||||
# or to impose a different order of visiting.
|
||||
|
||||
def walk(top, func, arg):
|
||||
"""Directory tree walk with callback function.
|
||||
|
||||
For each directory in the directory tree rooted at top (including top
|
||||
itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
|
||||
dirname is the name of the directory, and fnames a list of the names of
|
||||
the files and subdirectories in dirname (excluding '.' and '..'). func
|
||||
may modify the fnames list in-place (e.g. via del or slice assignment),
|
||||
and walk will only recurse into the subdirectories whose names remain in
|
||||
fnames; this can be used to implement a filter, or to impose a specific
|
||||
order of visiting. No semantics are defined for, or required of, arg,
|
||||
beyond that arg is always passed to func. It can be used, e.g., to pass
|
||||
a filename pattern, or a mutable object designed to accumulate
|
||||
statistics. Passing None for arg is common."""
|
||||
warnings.warnpy3k("In 3.x, os.path.walk is removed in favor of os.walk.",
|
||||
stacklevel=2)
|
||||
try:
|
||||
names = os.listdir(top)
|
||||
except os.error:
|
||||
return
|
||||
func(arg, top, names)
|
||||
for name in names:
|
||||
name = join(top, name)
|
||||
if isdir(name):
|
||||
walk(name, func, arg)
|
||||
|
||||
|
||||
# Expand paths beginning with '~' or '~user'.
|
||||
# '~' means $HOME; '~user' means that user's home directory.
|
||||
# If the path doesn't begin with '~', or if the user or $HOME is unknown,
|
||||
# the path is returned unchanged (leaving error reporting to whatever
|
||||
# function is called with the expanded path as argument).
|
||||
# See also module 'glob' for expansion of *, ? and [...] in pathnames.
|
||||
# (A function should also be defined to do full *sh-style environment
|
||||
# variable expansion.)
|
||||
|
||||
def expanduser(path):
|
||||
"""Expand ~ and ~user constructs.
|
||||
|
||||
If user or $HOME is unknown, do nothing."""
|
||||
if path[:1] != '~':
|
||||
return path
|
||||
i, n = 1, len(path)
|
||||
while i < n and path[i] not in '/\\':
|
||||
i = i + 1
|
||||
|
||||
if 'HOME' in os.environ:
|
||||
userhome = os.environ['HOME']
|
||||
elif 'USERPROFILE' in os.environ:
|
||||
userhome = os.environ['USERPROFILE']
|
||||
elif not 'HOMEPATH' in os.environ:
|
||||
return path
|
||||
else:
|
||||
try:
|
||||
drive = os.environ['HOMEDRIVE']
|
||||
except KeyError:
|
||||
drive = ''
|
||||
userhome = join(drive, os.environ['HOMEPATH'])
|
||||
|
||||
if i != 1: #~user
|
||||
userhome = join(dirname(userhome), path[1:i])
|
||||
|
||||
return userhome + path[i:]
|
||||
|
||||
|
||||
# Expand paths containing shell variable substitutions.
|
||||
# The following rules apply:
|
||||
# - no expansion within single quotes
|
||||
# - '$$' is translated into '$'
|
||||
# - '%%' is translated into '%' if '%%' are not seen in %var1%%var2%
|
||||
# - ${varname} is accepted.
|
||||
# - $varname is accepted.
|
||||
# - %varname% is accepted.
|
||||
# - varnames can be made out of letters, digits and the characters '_-'
|
||||
# (though is not verified in the ${varname} and %varname% cases)
|
||||
# XXX With COMMAND.COM you can use any characters in a variable name,
|
||||
# XXX except '^|<>='.
|
||||
|
||||
def expandvars(path):
|
||||
"""Expand shell variables of the forms $var, ${var} and %var%.
|
||||
|
||||
Unknown variables are left unchanged."""
|
||||
if '$' not in path and '%' not in path:
|
||||
return path
|
||||
import string
|
||||
varchars = string.ascii_letters + string.digits + '_-'
|
||||
if isinstance(path, _unicode):
|
||||
encoding = sys.getfilesystemencoding()
|
||||
def getenv(var):
|
||||
return os.environ[var.encode(encoding)].decode(encoding)
|
||||
else:
|
||||
def getenv(var):
|
||||
return os.environ[var]
|
||||
res = ''
|
||||
index = 0
|
||||
pathlen = len(path)
|
||||
while index < pathlen:
|
||||
c = path[index]
|
||||
if c == '\'': # no expansion within single quotes
|
||||
path = path[index + 1:]
|
||||
pathlen = len(path)
|
||||
try:
|
||||
index = path.index('\'')
|
||||
res = res + '\'' + path[:index + 1]
|
||||
except ValueError:
|
||||
res = res + c + path
|
||||
index = pathlen - 1
|
||||
elif c == '%': # variable or '%'
|
||||
if path[index + 1:index + 2] == '%':
|
||||
res = res + c
|
||||
index = index + 1
|
||||
else:
|
||||
path = path[index+1:]
|
||||
pathlen = len(path)
|
||||
try:
|
||||
index = path.index('%')
|
||||
except ValueError:
|
||||
res = res + '%' + path
|
||||
index = pathlen - 1
|
||||
else:
|
||||
var = path[:index]
|
||||
try:
|
||||
res = res + getenv(var)
|
||||
except KeyError:
|
||||
res = res + '%' + var + '%'
|
||||
elif c == '$': # variable or '$$'
|
||||
if path[index + 1:index + 2] == '$':
|
||||
res = res + c
|
||||
index = index + 1
|
||||
elif path[index + 1:index + 2] == '{':
|
||||
path = path[index+2:]
|
||||
pathlen = len(path)
|
||||
try:
|
||||
index = path.index('}')
|
||||
var = path[:index]
|
||||
try:
|
||||
res = res + getenv(var)
|
||||
except KeyError:
|
||||
res = res + '${' + var + '}'
|
||||
except ValueError:
|
||||
res = res + '${' + path
|
||||
index = pathlen - 1
|
||||
else:
|
||||
var = ''
|
||||
index = index + 1
|
||||
c = path[index:index + 1]
|
||||
while c != '' and c in varchars:
|
||||
var = var + c
|
||||
index = index + 1
|
||||
c = path[index:index + 1]
|
||||
try:
|
||||
res = res + getenv(var)
|
||||
except KeyError:
|
||||
res = res + '$' + var
|
||||
if c != '':
|
||||
index = index - 1
|
||||
else:
|
||||
res = res + c
|
||||
index = index + 1
|
||||
return res
|
||||
|
||||
|
||||
# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A\B.
|
||||
# Previously, this function also truncated pathnames to 8+3 format,
|
||||
# but as this module is called "ntpath", that's obviously wrong!
|
||||
|
||||
def normpath(path):
|
||||
"""Normalize path, eliminating double slashes, etc."""
|
||||
# Preserve unicode (if path is unicode)
|
||||
backslash, dot = (u'\\', u'.') if isinstance(path, _unicode) else ('\\', '.')
|
||||
if path.startswith(('\\\\.\\', '\\\\?\\')):
|
||||
# in the case of paths with these prefixes:
|
||||
# \\.\ -> device names
|
||||
# \\?\ -> literal paths
|
||||
# do not do any normalization, but return the path unchanged
|
||||
return path
|
||||
path = path.replace("/", "\\")
|
||||
prefix, path = splitdrive(path)
|
||||
# We need to be careful here. If the prefix is empty, and the path starts
|
||||
# with a backslash, it could either be an absolute path on the current
|
||||
# drive (\dir1\dir2\file) or a UNC filename (\\server\mount\dir1\file). It
|
||||
# is therefore imperative NOT to collapse multiple backslashes blindly in
|
||||
# that case.
|
||||
# The code below preserves multiple backslashes when there is no drive
|
||||
# letter. This means that the invalid filename \\\a\b is preserved
|
||||
# unchanged, where a\\\b is normalised to a\b. It's not clear that there
|
||||
# is any better behaviour for such edge cases.
|
||||
if prefix == '':
|
||||
# No drive letter - preserve initial backslashes
|
||||
while path[:1] == "\\":
|
||||
prefix = prefix + backslash
|
||||
path = path[1:]
|
||||
else:
|
||||
# We have a drive letter - collapse initial backslashes
|
||||
if path.startswith("\\"):
|
||||
prefix = prefix + backslash
|
||||
path = path.lstrip("\\")
|
||||
comps = path.split("\\")
|
||||
i = 0
|
||||
while i < len(comps):
|
||||
if comps[i] in ('.', ''):
|
||||
del comps[i]
|
||||
elif comps[i] == '..':
|
||||
if i > 0 and comps[i-1] != '..':
|
||||
del comps[i-1:i+1]
|
||||
i -= 1
|
||||
elif i == 0 and prefix.endswith("\\"):
|
||||
del comps[i]
|
||||
else:
|
||||
i += 1
|
||||
else:
|
||||
i += 1
|
||||
# If the path is now empty, substitute '.'
|
||||
if not prefix and not comps:
|
||||
comps.append(dot)
|
||||
return prefix + backslash.join(comps)
|
||||
|
||||
|
||||
# Return an absolute path.
|
||||
try:
|
||||
from nt import _getfullpathname
|
||||
|
||||
except ImportError: # not running on Windows - mock up something sensible
|
||||
def abspath(path):
|
||||
"""Return the absolute version of a path."""
|
||||
if not isabs(path):
|
||||
if isinstance(path, _unicode):
|
||||
cwd = os.getcwdu()
|
||||
else:
|
||||
cwd = os.getcwd()
|
||||
path = join(cwd, path)
|
||||
return normpath(path)
|
||||
|
||||
else: # use native Windows method on Windows
|
||||
def abspath(path):
|
||||
"""Return the absolute version of a path."""
|
||||
|
||||
if path: # Empty path must return current working directory.
|
||||
try:
|
||||
path = _getfullpathname(path)
|
||||
except WindowsError:
|
||||
pass # Bad path - return unchanged.
|
||||
elif isinstance(path, _unicode):
|
||||
path = os.getcwdu()
|
||||
else:
|
||||
path = os.getcwd()
|
||||
return normpath(path)
|
||||
|
||||
# realpath is a no-op on systems without islink support
|
||||
realpath = abspath
|
||||
# Win9x family and earlier have no Unicode filename support.
|
||||
supports_unicode_filenames = (hasattr(sys, "getwindowsversion") and
|
||||
sys.getwindowsversion()[3] >= 2)
|
||||
|
||||
def _abspath_split(path):
|
||||
abs = abspath(normpath(path))
|
||||
prefix, rest = splitunc(abs)
|
||||
is_unc = bool(prefix)
|
||||
if not is_unc:
|
||||
prefix, rest = splitdrive(abs)
|
||||
return is_unc, prefix, [x for x in rest.split(sep) if x]
|
||||
|
||||
def relpath(path, start=curdir):
|
||||
"""Return a relative version of a path"""
|
||||
|
||||
if not path:
|
||||
raise ValueError("no path specified")
|
||||
|
||||
start_is_unc, start_prefix, start_list = _abspath_split(start)
|
||||
path_is_unc, path_prefix, path_list = _abspath_split(path)
|
||||
|
||||
if path_is_unc ^ start_is_unc:
|
||||
raise ValueError("Cannot mix UNC and non-UNC paths (%s and %s)"
|
||||
% (path, start))
|
||||
if path_prefix.lower() != start_prefix.lower():
|
||||
if path_is_unc:
|
||||
raise ValueError("path is on UNC root %s, start on UNC root %s"
|
||||
% (path_prefix, start_prefix))
|
||||
else:
|
||||
raise ValueError("path is on drive %s, start on drive %s"
|
||||
% (path_prefix, start_prefix))
|
||||
# Work out how much of the filepath is shared by start and path.
|
||||
i = 0
|
||||
for e1, e2 in zip(start_list, path_list):
|
||||
if e1.lower() != e2.lower():
|
||||
break
|
||||
i += 1
|
||||
|
||||
rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
|
||||
if not rel_list:
|
||||
return curdir
|
||||
return join(*rel_list)
|
||||
|
||||
try:
|
||||
# The genericpath.isdir implementation uses os.stat and checks the mode
|
||||
# attribute to tell whether or not the path is a directory.
|
||||
# This is overkill on Windows - just pass the path to GetFileAttributes
|
||||
# and check the attribute from there.
|
||||
from nt import _isdir as isdir
|
||||
except ImportError:
|
||||
# Use genericpath.isdir as imported above.
|
||||
pass
|
742
AppPkg/Applications/Python/Python-2.7.10/PyMod-2.7.10/Lib/os.py
Normal file
742
AppPkg/Applications/Python/Python-2.7.10/PyMod-2.7.10/Lib/os.py
Normal file
@@ -0,0 +1,742 @@
|
||||
r"""OS routines for NT or Posix depending on what system we're on.
|
||||
|
||||
This exports:
|
||||
- all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.
|
||||
- os.path is one of the modules posixpath, or ntpath
|
||||
- os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'
|
||||
- os.curdir is a string representing the current directory ('.' or ':')
|
||||
- os.pardir is a string representing the parent directory ('..' or '::')
|
||||
- os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')
|
||||
- os.extsep is the extension separator ('.' or '/')
|
||||
- os.altsep is the alternate pathname separator (None or '/')
|
||||
- os.pathsep is the component separator used in $PATH etc
|
||||
- os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
|
||||
- os.defpath is the default search path for executables
|
||||
- os.devnull is the file path of the null device ('/dev/null', etc.)
|
||||
|
||||
Programs that import and use 'os' stand a better chance of being
|
||||
portable between different platforms. Of course, they must then
|
||||
only use functions that are defined by all platforms (e.g., unlink
|
||||
and opendir), and leave all pathname manipulation to os.path
|
||||
(e.g., split and join).
|
||||
"""
|
||||
|
||||
#'
|
||||
|
||||
import sys, errno
|
||||
|
||||
_names = sys.builtin_module_names
|
||||
|
||||
# Note: more names are added to __all__ later.
|
||||
__all__ = ["altsep", "curdir", "pardir", "sep", "extsep", "pathsep", "linesep",
|
||||
"defpath", "name", "path", "devnull",
|
||||
"SEEK_SET", "SEEK_CUR", "SEEK_END"]
|
||||
|
||||
def _get_exports_list(module):
|
||||
try:
|
||||
return list(module.__all__)
|
||||
except AttributeError:
|
||||
return [n for n in dir(module) if n[0] != '_']
|
||||
|
||||
if 'posix' in _names:
|
||||
name = 'posix'
|
||||
linesep = '\n'
|
||||
from posix import *
|
||||
try:
|
||||
from posix import _exit
|
||||
except ImportError:
|
||||
pass
|
||||
import posixpath as path
|
||||
|
||||
import posix
|
||||
__all__.extend(_get_exports_list(posix))
|
||||
del posix
|
||||
|
||||
elif 'nt' in _names:
|
||||
name = 'nt'
|
||||
linesep = '\r\n'
|
||||
from nt import *
|
||||
try:
|
||||
from nt import _exit
|
||||
except ImportError:
|
||||
pass
|
||||
import ntpath as path
|
||||
|
||||
import nt
|
||||
__all__.extend(_get_exports_list(nt))
|
||||
del nt
|
||||
|
||||
elif 'os2' in _names:
|
||||
name = 'os2'
|
||||
linesep = '\r\n'
|
||||
from os2 import *
|
||||
try:
|
||||
from os2 import _exit
|
||||
except ImportError:
|
||||
pass
|
||||
if sys.version.find('EMX GCC') == -1:
|
||||
import ntpath as path
|
||||
else:
|
||||
import os2emxpath as path
|
||||
from _emx_link import link
|
||||
|
||||
import os2
|
||||
__all__.extend(_get_exports_list(os2))
|
||||
del os2
|
||||
|
||||
elif 'ce' in _names:
|
||||
name = 'ce'
|
||||
linesep = '\r\n'
|
||||
from ce import *
|
||||
try:
|
||||
from ce import _exit
|
||||
except ImportError:
|
||||
pass
|
||||
# We can use the standard Windows path.
|
||||
import ntpath as path
|
||||
|
||||
import ce
|
||||
__all__.extend(_get_exports_list(ce))
|
||||
del ce
|
||||
|
||||
elif 'riscos' in _names:
|
||||
name = 'riscos'
|
||||
linesep = '\n'
|
||||
from riscos import *
|
||||
try:
|
||||
from riscos import _exit
|
||||
except ImportError:
|
||||
pass
|
||||
import riscospath as path
|
||||
|
||||
import riscos
|
||||
__all__.extend(_get_exports_list(riscos))
|
||||
del riscos
|
||||
|
||||
else:
|
||||
raise ImportError, 'no os specific module found'
|
||||
|
||||
sys.modules['os.path'] = path
|
||||
from os.path import (curdir, pardir, sep, pathsep, defpath, extsep, altsep,
|
||||
devnull)
|
||||
|
||||
del _names
|
||||
|
||||
# Python uses fixed values for the SEEK_ constants; they are mapped
|
||||
# to native constants if necessary in posixmodule.c
|
||||
SEEK_SET = 0
|
||||
SEEK_CUR = 1
|
||||
SEEK_END = 2
|
||||
|
||||
#'
|
||||
|
||||
# Super directory utilities.
|
||||
# (Inspired by Eric Raymond; the doc strings are mostly his)
|
||||
|
||||
def makedirs(name, mode=0777):
|
||||
"""makedirs(path [, mode=0777])
|
||||
|
||||
Super-mkdir; create a leaf directory and all intermediate ones.
|
||||
Works like mkdir, except that any intermediate path segment (not
|
||||
just the rightmost) will be created if it does not exist. This is
|
||||
recursive.
|
||||
|
||||
"""
|
||||
head, tail = path.split(name)
|
||||
if not tail:
|
||||
head, tail = path.split(head)
|
||||
if head and tail and not path.exists(head):
|
||||
try:
|
||||
makedirs(head, mode)
|
||||
except OSError, e:
|
||||
# be happy if someone already created the path
|
||||
if e.errno != errno.EEXIST:
|
||||
raise
|
||||
if tail == curdir: # xxx/newdir/. exists if xxx/newdir exists
|
||||
return
|
||||
mkdir(name, mode)
|
||||
|
||||
def removedirs(name):
|
||||
"""removedirs(path)
|
||||
|
||||
Super-rmdir; remove a leaf directory and all empty intermediate
|
||||
ones. Works like rmdir except that, if the leaf directory is
|
||||
successfully removed, directories corresponding to rightmost path
|
||||
segments will be pruned away until either the whole path is
|
||||
consumed or an error occurs. Errors during this latter phase are
|
||||
ignored -- they generally mean that a directory was not empty.
|
||||
|
||||
"""
|
||||
rmdir(name)
|
||||
head, tail = path.split(name)
|
||||
if not tail:
|
||||
head, tail = path.split(head)
|
||||
while head and tail:
|
||||
try:
|
||||
rmdir(head)
|
||||
except error:
|
||||
break
|
||||
head, tail = path.split(head)
|
||||
|
||||
def renames(old, new):
|
||||
"""renames(old, new)
|
||||
|
||||
Super-rename; create directories as necessary and delete any left
|
||||
empty. Works like rename, except creation of any intermediate
|
||||
directories needed to make the new pathname good is attempted
|
||||
first. After the rename, directories corresponding to rightmost
|
||||
path segments of the old name will be pruned until either the
|
||||
whole path is consumed or a nonempty directory is found.
|
||||
|
||||
Note: this function can fail with the new directory structure made
|
||||
if you lack permissions needed to unlink the leaf directory or
|
||||
file.
|
||||
|
||||
"""
|
||||
head, tail = path.split(new)
|
||||
if head and tail and not path.exists(head):
|
||||
makedirs(head)
|
||||
rename(old, new)
|
||||
head, tail = path.split(old)
|
||||
if head and tail:
|
||||
try:
|
||||
removedirs(head)
|
||||
except error:
|
||||
pass
|
||||
|
||||
__all__.extend(["makedirs", "removedirs", "renames"])
|
||||
|
||||
def walk(top, topdown=True, onerror=None, followlinks=False):
|
||||
"""Directory tree generator.
|
||||
|
||||
For each directory in the directory tree rooted at top (including top
|
||||
itself, but excluding '.' and '..'), yields a 3-tuple
|
||||
|
||||
dirpath, dirnames, filenames
|
||||
|
||||
dirpath is a string, the path to the directory. dirnames is a list of
|
||||
the names of the subdirectories in dirpath (excluding '.' and '..').
|
||||
filenames is a list of the names of the non-directory files in dirpath.
|
||||
Note that the names in the lists are just names, with no path components.
|
||||
To get a full path (which begins with top) to a file or directory in
|
||||
dirpath, do os.path.join(dirpath, name).
|
||||
|
||||
If optional arg 'topdown' is true or not specified, the triple for a
|
||||
directory is generated before the triples for any of its subdirectories
|
||||
(directories are generated top down). If topdown is false, the triple
|
||||
for a directory is generated after the triples for all of its
|
||||
subdirectories (directories are generated bottom up).
|
||||
|
||||
When topdown is true, the caller can modify the dirnames list in-place
|
||||
(e.g., via del or slice assignment), and walk will only recurse into the
|
||||
subdirectories whose names remain in dirnames; this can be used to prune the
|
||||
search, or to impose a specific order of visiting. Modifying dirnames when
|
||||
topdown is false is ineffective, since the directories in dirnames have
|
||||
already been generated by the time dirnames itself is generated. No matter
|
||||
the value of topdown, the list of subdirectories is retrieved before the
|
||||
tuples for the directory and its subdirectories are generated.
|
||||
|
||||
By default errors from the os.listdir() call are ignored. If
|
||||
optional arg 'onerror' is specified, it should be a function; it
|
||||
will be called with one argument, an os.error instance. It can
|
||||
report the error to continue with the walk, or raise the exception
|
||||
to abort the walk. Note that the filename is available as the
|
||||
filename attribute of the exception object.
|
||||
|
||||
By default, os.walk does not follow symbolic links to subdirectories on
|
||||
systems that support them. In order to get this functionality, set the
|
||||
optional argument 'followlinks' to true.
|
||||
|
||||
Caution: if you pass a relative pathname for top, don't change the
|
||||
current working directory between resumptions of walk. walk never
|
||||
changes the current directory, and assumes that the client doesn't
|
||||
either.
|
||||
|
||||
Example:
|
||||
|
||||
import os
|
||||
from os.path import join, getsize
|
||||
for root, dirs, files in os.walk('python/Lib/email'):
|
||||
print root, "consumes",
|
||||
print sum([getsize(join(root, name)) for name in files]),
|
||||
print "bytes in", len(files), "non-directory files"
|
||||
if 'CVS' in dirs:
|
||||
dirs.remove('CVS') # don't visit CVS directories
|
||||
|
||||
"""
|
||||
|
||||
islink, join, isdir = path.islink, path.join, path.isdir
|
||||
|
||||
# We may not have read permission for top, in which case we can't
|
||||
# get a list of the files the directory contains. os.path.walk
|
||||
# always suppressed the exception then, rather than blow up for a
|
||||
# minor reason when (say) a thousand readable directories are still
|
||||
# left to visit. That logic is copied here.
|
||||
try:
|
||||
# Note that listdir and error are globals in this module due
|
||||
# to earlier import-*.
|
||||
names = listdir(top)
|
||||
except error, err:
|
||||
if onerror is not None:
|
||||
onerror(err)
|
||||
return
|
||||
|
||||
dirs, nondirs = [], []
|
||||
for name in names:
|
||||
if isdir(join(top, name)):
|
||||
dirs.append(name)
|
||||
else:
|
||||
nondirs.append(name)
|
||||
|
||||
if topdown:
|
||||
yield top, dirs, nondirs
|
||||
for name in dirs:
|
||||
new_path = join(top, name)
|
||||
if followlinks or not islink(new_path):
|
||||
for x in walk(new_path, topdown, onerror, followlinks):
|
||||
yield x
|
||||
if not topdown:
|
||||
yield top, dirs, nondirs
|
||||
|
||||
__all__.append("walk")
|
||||
|
||||
# Make sure os.environ exists, at least
|
||||
try:
|
||||
environ
|
||||
except NameError:
|
||||
environ = {}
|
||||
|
||||
def execl(file, *args):
|
||||
"""execl(file, *args)
|
||||
|
||||
Execute the executable file with argument list args, replacing the
|
||||
current process. """
|
||||
execv(file, args)
|
||||
|
||||
def execle(file, *args):
|
||||
"""execle(file, *args, env)
|
||||
|
||||
Execute the executable file with argument list args and
|
||||
environment env, replacing the current process. """
|
||||
env = args[-1]
|
||||
execve(file, args[:-1], env)
|
||||
|
||||
def execlp(file, *args):
|
||||
"""execlp(file, *args)
|
||||
|
||||
Execute the executable file (which is searched for along $PATH)
|
||||
with argument list args, replacing the current process. """
|
||||
execvp(file, args)
|
||||
|
||||
def execlpe(file, *args):
|
||||
"""execlpe(file, *args, env)
|
||||
|
||||
Execute the executable file (which is searched for along $PATH)
|
||||
with argument list args and environment env, replacing the current
|
||||
process. """
|
||||
env = args[-1]
|
||||
execvpe(file, args[:-1], env)
|
||||
|
||||
def execvp(file, args):
|
||||
"""execvp(file, args)
|
||||
|
||||
Execute the executable file (which is searched for along $PATH)
|
||||
with argument list args, replacing the current process.
|
||||
args may be a list or tuple of strings. """
|
||||
_execvpe(file, args)
|
||||
|
||||
def execvpe(file, args, env):
|
||||
"""execvpe(file, args, env)
|
||||
|
||||
Execute the executable file (which is searched for along $PATH)
|
||||
with argument list args and environment env , replacing the
|
||||
current process.
|
||||
args may be a list or tuple of strings. """
|
||||
_execvpe(file, args, env)
|
||||
|
||||
__all__.extend(["execl","execle","execlp","execlpe","execvp","execvpe"])
|
||||
|
||||
def _execvpe(file, args, env=None):
|
||||
if env is not None:
|
||||
func = execve
|
||||
argrest = (args, env)
|
||||
else:
|
||||
func = execv
|
||||
argrest = (args,)
|
||||
env = environ
|
||||
|
||||
head, tail = path.split(file)
|
||||
if head:
|
||||
func(file, *argrest)
|
||||
return
|
||||
if 'PATH' in env:
|
||||
envpath = env['PATH']
|
||||
else:
|
||||
envpath = defpath
|
||||
PATH = envpath.split(pathsep)
|
||||
saved_exc = None
|
||||
saved_tb = None
|
||||
for dir in PATH:
|
||||
fullname = path.join(dir, file)
|
||||
try:
|
||||
func(fullname, *argrest)
|
||||
except error, e:
|
||||
tb = sys.exc_info()[2]
|
||||
if (e.errno != errno.ENOENT and e.errno != errno.ENOTDIR
|
||||
and saved_exc is None):
|
||||
saved_exc = e
|
||||
saved_tb = tb
|
||||
if saved_exc:
|
||||
raise error, saved_exc, saved_tb
|
||||
raise error, e, tb
|
||||
|
||||
# Change environ to automatically call putenv() if it exists
|
||||
try:
|
||||
# This will fail if there's no putenv
|
||||
putenv
|
||||
except NameError:
|
||||
pass
|
||||
else:
|
||||
import UserDict
|
||||
|
||||
# Fake unsetenv() for Windows
|
||||
# not sure about os2 here but
|
||||
# I'm guessing they are the same.
|
||||
|
||||
if name in ('os2', 'nt'):
|
||||
def unsetenv(key):
|
||||
putenv(key, "")
|
||||
|
||||
if name == "riscos":
|
||||
# On RISC OS, all env access goes through getenv and putenv
|
||||
from riscosenviron import _Environ
|
||||
elif name in ('os2', 'nt'): # Where Env Var Names Must Be UPPERCASE
|
||||
# But we store them as upper case
|
||||
class _Environ(UserDict.IterableUserDict):
|
||||
def __init__(self, environ):
|
||||
UserDict.UserDict.__init__(self)
|
||||
data = self.data
|
||||
for k, v in environ.items():
|
||||
data[k.upper()] = v
|
||||
def __setitem__(self, key, item):
|
||||
putenv(key, item)
|
||||
self.data[key.upper()] = item
|
||||
def __getitem__(self, key):
|
||||
return self.data[key.upper()]
|
||||
try:
|
||||
unsetenv
|
||||
except NameError:
|
||||
def __delitem__(self, key):
|
||||
del self.data[key.upper()]
|
||||
else:
|
||||
def __delitem__(self, key):
|
||||
unsetenv(key)
|
||||
del self.data[key.upper()]
|
||||
def clear(self):
|
||||
for key in self.data.keys():
|
||||
unsetenv(key)
|
||||
del self.data[key]
|
||||
def pop(self, key, *args):
|
||||
unsetenv(key)
|
||||
return self.data.pop(key.upper(), *args)
|
||||
def has_key(self, key):
|
||||
return key.upper() in self.data
|
||||
def __contains__(self, key):
|
||||
return key.upper() in self.data
|
||||
def get(self, key, failobj=None):
|
||||
return self.data.get(key.upper(), failobj)
|
||||
def update(self, dict=None, **kwargs):
|
||||
if dict:
|
||||
try:
|
||||
keys = dict.keys()
|
||||
except AttributeError:
|
||||
# List of (key, value)
|
||||
for k, v in dict:
|
||||
self[k] = v
|
||||
else:
|
||||
# got keys
|
||||
# cannot use items(), since mappings
|
||||
# may not have them.
|
||||
for k in keys:
|
||||
self[k] = dict[k]
|
||||
if kwargs:
|
||||
self.update(kwargs)
|
||||
def copy(self):
|
||||
return dict(self)
|
||||
|
||||
else: # Where Env Var Names Can Be Mixed Case
|
||||
class _Environ(UserDict.IterableUserDict):
|
||||
def __init__(self, environ):
|
||||
UserDict.UserDict.__init__(self)
|
||||
self.data = environ
|
||||
def __setitem__(self, key, item):
|
||||
putenv(key, item)
|
||||
self.data[key] = item
|
||||
def update(self, dict=None, **kwargs):
|
||||
if dict:
|
||||
try:
|
||||
keys = dict.keys()
|
||||
except AttributeError:
|
||||
# List of (key, value)
|
||||
for k, v in dict:
|
||||
self[k] = v
|
||||
else:
|
||||
# got keys
|
||||
# cannot use items(), since mappings
|
||||
# may not have them.
|
||||
for k in keys:
|
||||
self[k] = dict[k]
|
||||
if kwargs:
|
||||
self.update(kwargs)
|
||||
try:
|
||||
unsetenv
|
||||
except NameError:
|
||||
pass
|
||||
else:
|
||||
def __delitem__(self, key):
|
||||
unsetenv(key)
|
||||
del self.data[key]
|
||||
def clear(self):
|
||||
for key in self.data.keys():
|
||||
unsetenv(key)
|
||||
del self.data[key]
|
||||
def pop(self, key, *args):
|
||||
unsetenv(key)
|
||||
return self.data.pop(key, *args)
|
||||
def copy(self):
|
||||
return dict(self)
|
||||
|
||||
|
||||
environ = _Environ(environ)
|
||||
|
||||
def getenv(key, default=None):
|
||||
"""Get an environment variable, return None if it doesn't exist.
|
||||
The optional second argument can specify an alternate default."""
|
||||
return environ.get(key, default)
|
||||
__all__.append("getenv")
|
||||
|
||||
def _exists(name):
|
||||
return name in globals()
|
||||
|
||||
# Supply spawn*() (probably only for Unix)
|
||||
if _exists("fork") and not _exists("spawnv") and _exists("execv"):
|
||||
|
||||
P_WAIT = 0
|
||||
P_NOWAIT = P_NOWAITO = 1
|
||||
|
||||
# XXX Should we support P_DETACH? I suppose it could fork()**2
|
||||
# and close the std I/O streams. Also, P_OVERLAY is the same
|
||||
# as execv*()?
|
||||
|
||||
def _spawnvef(mode, file, args, env, func):
|
||||
# Internal helper; func is the exec*() function to use
|
||||
pid = fork()
|
||||
if not pid:
|
||||
# Child
|
||||
try:
|
||||
if env is None:
|
||||
func(file, args)
|
||||
else:
|
||||
func(file, args, env)
|
||||
except:
|
||||
_exit(127)
|
||||
else:
|
||||
# Parent
|
||||
if mode == P_NOWAIT:
|
||||
return pid # Caller is responsible for waiting!
|
||||
while 1:
|
||||
wpid, sts = waitpid(pid, 0)
|
||||
if WIFSTOPPED(sts):
|
||||
continue
|
||||
elif WIFSIGNALED(sts):
|
||||
return -WTERMSIG(sts)
|
||||
elif WIFEXITED(sts):
|
||||
return WEXITSTATUS(sts)
|
||||
else:
|
||||
raise error, "Not stopped, signaled or exited???"
|
||||
|
||||
def spawnv(mode, file, args):
|
||||
"""spawnv(mode, file, args) -> integer
|
||||
|
||||
Execute file with arguments from args in a subprocess.
|
||||
If mode == P_NOWAIT return the pid of the process.
|
||||
If mode == P_WAIT return the process's exit code if it exits normally;
|
||||
otherwise return -SIG, where SIG is the signal that killed it. """
|
||||
return _spawnvef(mode, file, args, None, execv)
|
||||
|
||||
def spawnve(mode, file, args, env):
|
||||
"""spawnve(mode, file, args, env) -> integer
|
||||
|
||||
Execute file with arguments from args in a subprocess with the
|
||||
specified environment.
|
||||
If mode == P_NOWAIT return the pid of the process.
|
||||
If mode == P_WAIT return the process's exit code if it exits normally;
|
||||
otherwise return -SIG, where SIG is the signal that killed it. """
|
||||
return _spawnvef(mode, file, args, env, execve)
|
||||
|
||||
# Note: spawnvp[e] is't currently supported on Windows
|
||||
|
||||
def spawnvp(mode, file, args):
|
||||
"""spawnvp(mode, file, args) -> integer
|
||||
|
||||
Execute file (which is looked for along $PATH) with arguments from
|
||||
args in a subprocess.
|
||||
If mode == P_NOWAIT return the pid of the process.
|
||||
If mode == P_WAIT return the process's exit code if it exits normally;
|
||||
otherwise return -SIG, where SIG is the signal that killed it. """
|
||||
return _spawnvef(mode, file, args, None, execvp)
|
||||
|
||||
def spawnvpe(mode, file, args, env):
|
||||
"""spawnvpe(mode, file, args, env) -> integer
|
||||
|
||||
Execute file (which is looked for along $PATH) with arguments from
|
||||
args in a subprocess with the supplied environment.
|
||||
If mode == P_NOWAIT return the pid of the process.
|
||||
If mode == P_WAIT return the process's exit code if it exits normally;
|
||||
otherwise return -SIG, where SIG is the signal that killed it. """
|
||||
return _spawnvef(mode, file, args, env, execvpe)
|
||||
|
||||
if _exists("spawnv"):
|
||||
# These aren't supplied by the basic Windows code
|
||||
# but can be easily implemented in Python
|
||||
|
||||
def spawnl(mode, file, *args):
|
||||
"""spawnl(mode, file, *args) -> integer
|
||||
|
||||
Execute file with arguments from args in a subprocess.
|
||||
If mode == P_NOWAIT return the pid of the process.
|
||||
If mode == P_WAIT return the process's exit code if it exits normally;
|
||||
otherwise return -SIG, where SIG is the signal that killed it. """
|
||||
return spawnv(mode, file, args)
|
||||
|
||||
def spawnle(mode, file, *args):
|
||||
"""spawnle(mode, file, *args, env) -> integer
|
||||
|
||||
Execute file with arguments from args in a subprocess with the
|
||||
supplied environment.
|
||||
If mode == P_NOWAIT return the pid of the process.
|
||||
If mode == P_WAIT return the process's exit code if it exits normally;
|
||||
otherwise return -SIG, where SIG is the signal that killed it. """
|
||||
env = args[-1]
|
||||
return spawnve(mode, file, args[:-1], env)
|
||||
|
||||
|
||||
__all__.extend(["spawnv", "spawnve", "spawnl", "spawnle",])
|
||||
|
||||
|
||||
if _exists("spawnvp"):
|
||||
# At the moment, Windows doesn't implement spawnvp[e],
|
||||
# so it won't have spawnlp[e] either.
|
||||
def spawnlp(mode, file, *args):
|
||||
"""spawnlp(mode, file, *args) -> integer
|
||||
|
||||
Execute file (which is looked for along $PATH) with arguments from
|
||||
args in a subprocess with the supplied environment.
|
||||
If mode == P_NOWAIT return the pid of the process.
|
||||
If mode == P_WAIT return the process's exit code if it exits normally;
|
||||
otherwise return -SIG, where SIG is the signal that killed it. """
|
||||
return spawnvp(mode, file, args)
|
||||
|
||||
def spawnlpe(mode, file, *args):
|
||||
"""spawnlpe(mode, file, *args, env) -> integer
|
||||
|
||||
Execute file (which is looked for along $PATH) with arguments from
|
||||
args in a subprocess with the supplied environment.
|
||||
If mode == P_NOWAIT return the pid of the process.
|
||||
If mode == P_WAIT return the process's exit code if it exits normally;
|
||||
otherwise return -SIG, where SIG is the signal that killed it. """
|
||||
env = args[-1]
|
||||
return spawnvpe(mode, file, args[:-1], env)
|
||||
|
||||
|
||||
__all__.extend(["spawnvp", "spawnvpe", "spawnlp", "spawnlpe",])
|
||||
|
||||
|
||||
# Supply popen2 etc. (for Unix)
|
||||
if _exists("fork"):
|
||||
if not _exists("popen2"):
|
||||
def popen2(cmd, mode="t", bufsize=-1):
|
||||
"""Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd'
|
||||
may be a sequence, in which case arguments will be passed directly to
|
||||
the program without shell intervention (as with os.spawnv()). If 'cmd'
|
||||
is a string it will be passed to the shell (as with os.system()). If
|
||||
'bufsize' is specified, it sets the buffer size for the I/O pipes. The
|
||||
file objects (child_stdin, child_stdout) are returned."""
|
||||
import warnings
|
||||
msg = "os.popen2 is deprecated. Use the subprocess module."
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
|
||||
import subprocess
|
||||
PIPE = subprocess.PIPE
|
||||
p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
|
||||
bufsize=bufsize, stdin=PIPE, stdout=PIPE,
|
||||
close_fds=True)
|
||||
return p.stdin, p.stdout
|
||||
__all__.append("popen2")
|
||||
|
||||
if not _exists("popen3"):
|
||||
def popen3(cmd, mode="t", bufsize=-1):
|
||||
"""Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd'
|
||||
may be a sequence, in which case arguments will be passed directly to
|
||||
the program without shell intervention (as with os.spawnv()). If 'cmd'
|
||||
is a string it will be passed to the shell (as with os.system()). If
|
||||
'bufsize' is specified, it sets the buffer size for the I/O pipes. The
|
||||
file objects (child_stdin, child_stdout, child_stderr) are returned."""
|
||||
import warnings
|
||||
msg = "os.popen3 is deprecated. Use the subprocess module."
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
|
||||
import subprocess
|
||||
PIPE = subprocess.PIPE
|
||||
p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
|
||||
bufsize=bufsize, stdin=PIPE, stdout=PIPE,
|
||||
stderr=PIPE, close_fds=True)
|
||||
return p.stdin, p.stdout, p.stderr
|
||||
__all__.append("popen3")
|
||||
|
||||
if not _exists("popen4"):
|
||||
def popen4(cmd, mode="t", bufsize=-1):
|
||||
"""Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd'
|
||||
may be a sequence, in which case arguments will be passed directly to
|
||||
the program without shell intervention (as with os.spawnv()). If 'cmd'
|
||||
is a string it will be passed to the shell (as with os.system()). If
|
||||
'bufsize' is specified, it sets the buffer size for the I/O pipes. The
|
||||
file objects (child_stdin, child_stdout_stderr) are returned."""
|
||||
import warnings
|
||||
msg = "os.popen4 is deprecated. Use the subprocess module."
|
||||
warnings.warn(msg, DeprecationWarning, stacklevel=2)
|
||||
|
||||
import subprocess
|
||||
PIPE = subprocess.PIPE
|
||||
p = subprocess.Popen(cmd, shell=isinstance(cmd, basestring),
|
||||
bufsize=bufsize, stdin=PIPE, stdout=PIPE,
|
||||
stderr=subprocess.STDOUT, close_fds=True)
|
||||
return p.stdin, p.stdout
|
||||
__all__.append("popen4")
|
||||
|
||||
import copy_reg as _copy_reg
|
||||
|
||||
def _make_stat_result(tup, dict):
|
||||
return stat_result(tup, dict)
|
||||
|
||||
def _pickle_stat_result(sr):
|
||||
(type, args) = sr.__reduce__()
|
||||
return (_make_stat_result, args)
|
||||
|
||||
try:
|
||||
_copy_reg.pickle(stat_result, _pickle_stat_result, _make_stat_result)
|
||||
except NameError: # stat_result may not exist
|
||||
pass
|
||||
|
||||
def _make_statvfs_result(tup, dict):
|
||||
return statvfs_result(tup, dict)
|
||||
|
||||
def _pickle_statvfs_result(sr):
|
||||
(type, args) = sr.__reduce__()
|
||||
return (_make_statvfs_result, args)
|
||||
|
||||
try:
|
||||
_copy_reg.pickle(statvfs_result, _pickle_statvfs_result,
|
||||
_make_statvfs_result)
|
||||
except NameError: # statvfs_result may not exist
|
||||
pass
|
2406
AppPkg/Applications/Python/Python-2.7.10/PyMod-2.7.10/Lib/pydoc.py
Normal file
2406
AppPkg/Applications/Python/Python-2.7.10/PyMod-2.7.10/Lib/pydoc.py
Normal file
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,600 @@
|
||||
"""Append module search paths for third-party packages to sys.path.
|
||||
|
||||
****************************************************************
|
||||
* This module is automatically imported during initialization. *
|
||||
****************************************************************
|
||||
|
||||
In earlier versions of Python (up to 1.5a3), scripts or modules that
|
||||
needed to use site-specific modules would place ``import site''
|
||||
somewhere near the top of their code. Because of the automatic
|
||||
import, this is no longer necessary (but code that does it still
|
||||
works).
|
||||
|
||||
This will append site-specific paths to the module search path. On
|
||||
Unix (including Mac OSX), it starts with sys.prefix and
|
||||
sys.exec_prefix (if different) and appends
|
||||
lib/python<version>/site-packages as well as lib/site-python.
|
||||
On other platforms (such as Windows), it tries each of the
|
||||
prefixes directly, as well as with lib/site-packages appended. The
|
||||
resulting directories, if they exist, are appended to sys.path, and
|
||||
also inspected for path configuration files.
|
||||
|
||||
A path configuration file is a file whose name has the form
|
||||
<package>.pth; its contents are additional directories (one per line)
|
||||
to be added to sys.path. Non-existing directories (or
|
||||
non-directories) are never added to sys.path; no directory is added to
|
||||
sys.path more than once. Blank lines and lines beginning with
|
||||
'#' are skipped. Lines starting with 'import' are executed.
|
||||
|
||||
For example, suppose sys.prefix and sys.exec_prefix are set to
|
||||
/usr/local and there is a directory /usr/local/lib/python2.5/site-packages
|
||||
with three subdirectories, foo, bar and spam, and two path
|
||||
configuration files, foo.pth and bar.pth. Assume foo.pth contains the
|
||||
following:
|
||||
|
||||
# foo package configuration
|
||||
foo
|
||||
bar
|
||||
bletch
|
||||
|
||||
and bar.pth contains:
|
||||
|
||||
# bar package configuration
|
||||
bar
|
||||
|
||||
Then the following directories are added to sys.path, in this order:
|
||||
|
||||
/usr/local/lib/python2.5/site-packages/bar
|
||||
/usr/local/lib/python2.5/site-packages/foo
|
||||
|
||||
Note that bletch is omitted because it doesn't exist; bar precedes foo
|
||||
because bar.pth comes alphabetically before foo.pth; and spam is
|
||||
omitted because it is not mentioned in either path configuration file.
|
||||
|
||||
After these path manipulations, an attempt is made to import a module
|
||||
named sitecustomize, which can perform arbitrary additional
|
||||
site-specific customizations. If this import fails with an
|
||||
ImportError exception, it is silently ignored.
|
||||
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import __builtin__
|
||||
import traceback
|
||||
|
||||
# Prefixes for site-packages; add additional prefixes like /usr/local here
|
||||
PREFIXES = [sys.prefix, sys.exec_prefix]
|
||||
# Enable per user site-packages directory
|
||||
# set it to False to disable the feature or True to force the feature
|
||||
ENABLE_USER_SITE = None
|
||||
|
||||
# for distutils.commands.install
|
||||
# These values are initialized by the getuserbase() and getusersitepackages()
|
||||
# functions, through the main() function when Python starts.
|
||||
USER_SITE = None
|
||||
USER_BASE = None
|
||||
|
||||
|
||||
def makepath(*paths):
|
||||
dir = os.path.join(*paths)
|
||||
try:
|
||||
dir = os.path.abspath(dir)
|
||||
except OSError:
|
||||
pass
|
||||
return dir, os.path.normcase(dir)
|
||||
|
||||
|
||||
def abs__file__():
|
||||
"""Set all module' __file__ attribute to an absolute path"""
|
||||
for m in sys.modules.values():
|
||||
if hasattr(m, '__loader__'):
|
||||
continue # don't mess with a PEP 302-supplied __file__
|
||||
try:
|
||||
m.__file__ = os.path.abspath(m.__file__)
|
||||
except (AttributeError, OSError):
|
||||
pass
|
||||
|
||||
|
||||
def removeduppaths():
|
||||
""" Remove duplicate entries from sys.path along with making them
|
||||
absolute"""
|
||||
# This ensures that the initial path provided by the interpreter contains
|
||||
# only absolute pathnames, even if we're running from the build directory.
|
||||
L = []
|
||||
known_paths = set()
|
||||
for dir in sys.path:
|
||||
# Filter out duplicate paths (on case-insensitive file systems also
|
||||
# if they only differ in case); turn relative paths into absolute
|
||||
# paths.
|
||||
dir, dircase = makepath(dir)
|
||||
if not dircase in known_paths:
|
||||
L.append(dir)
|
||||
known_paths.add(dircase)
|
||||
sys.path[:] = L
|
||||
return known_paths
|
||||
|
||||
|
||||
def _init_pathinfo():
|
||||
"""Return a set containing all existing directory entries from sys.path"""
|
||||
d = set()
|
||||
for dir in sys.path:
|
||||
try:
|
||||
if os.path.isdir(dir):
|
||||
dir, dircase = makepath(dir)
|
||||
d.add(dircase)
|
||||
except TypeError:
|
||||
continue
|
||||
return d
|
||||
|
||||
|
||||
def addpackage(sitedir, name, known_paths):
|
||||
"""Process a .pth file within the site-packages directory:
|
||||
For each line in the file, either combine it with sitedir to a path
|
||||
and add that to known_paths, or execute it if it starts with 'import '.
|
||||
"""
|
||||
if known_paths is None:
|
||||
_init_pathinfo()
|
||||
reset = 1
|
||||
else:
|
||||
reset = 0
|
||||
fullname = os.path.join(sitedir, name)
|
||||
try:
|
||||
f = open(fullname, "rU")
|
||||
except IOError:
|
||||
return
|
||||
with f:
|
||||
for n, line in enumerate(f):
|
||||
if line.startswith("#"):
|
||||
continue
|
||||
try:
|
||||
if line.startswith(("import ", "import\t")):
|
||||
exec line
|
||||
continue
|
||||
line = line.rstrip()
|
||||
dir, dircase = makepath(sitedir, line)
|
||||
if not dircase in known_paths and os.path.exists(dir):
|
||||
sys.path.append(dir)
|
||||
known_paths.add(dircase)
|
||||
except Exception as err:
|
||||
print >>sys.stderr, "Error processing line {:d} of {}:\n".format(
|
||||
n+1, fullname)
|
||||
for record in traceback.format_exception(*sys.exc_info()):
|
||||
for line in record.splitlines():
|
||||
print >>sys.stderr, ' '+line
|
||||
print >>sys.stderr, "\nRemainder of file ignored"
|
||||
break
|
||||
if reset:
|
||||
known_paths = None
|
||||
return known_paths
|
||||
|
||||
|
||||
def addsitedir(sitedir, known_paths=None):
|
||||
"""Add 'sitedir' argument to sys.path if missing and handle .pth files in
|
||||
'sitedir'"""
|
||||
if known_paths is None:
|
||||
known_paths = _init_pathinfo()
|
||||
reset = 1
|
||||
else:
|
||||
reset = 0
|
||||
sitedir, sitedircase = makepath(sitedir)
|
||||
if not sitedircase in known_paths:
|
||||
sys.path.append(sitedir) # Add path component
|
||||
try:
|
||||
names = os.listdir(sitedir)
|
||||
except os.error:
|
||||
return
|
||||
dotpth = os.extsep + "pth"
|
||||
names = [name for name in names if name.endswith(dotpth)]
|
||||
for name in sorted(names):
|
||||
addpackage(sitedir, name, known_paths)
|
||||
if reset:
|
||||
known_paths = None
|
||||
return known_paths
|
||||
|
||||
|
||||
def check_enableusersite():
|
||||
"""Check if user site directory is safe for inclusion
|
||||
|
||||
The function tests for the command line flag (including environment var),
|
||||
process uid/gid equal to effective uid/gid.
|
||||
|
||||
None: Disabled for security reasons
|
||||
False: Disabled by user (command line option)
|
||||
True: Safe and enabled
|
||||
"""
|
||||
if sys.flags.no_user_site:
|
||||
return False
|
||||
|
||||
if hasattr(os, "getuid") and hasattr(os, "geteuid"):
|
||||
# check process uid == effective uid
|
||||
if os.geteuid() != os.getuid():
|
||||
return None
|
||||
if hasattr(os, "getgid") and hasattr(os, "getegid"):
|
||||
# check process gid == effective gid
|
||||
if os.getegid() != os.getgid():
|
||||
return None
|
||||
|
||||
return True
|
||||
|
||||
def getuserbase():
|
||||
"""Returns the `user base` directory path.
|
||||
|
||||
The `user base` directory can be used to store data. If the global
|
||||
variable ``USER_BASE`` is not initialized yet, this function will also set
|
||||
it.
|
||||
"""
|
||||
global USER_BASE
|
||||
if USER_BASE is not None:
|
||||
return USER_BASE
|
||||
from sysconfig import get_config_var
|
||||
USER_BASE = get_config_var('userbase')
|
||||
return USER_BASE
|
||||
|
||||
def getusersitepackages():
|
||||
"""Returns the user-specific site-packages directory path.
|
||||
|
||||
If the global variable ``USER_SITE`` is not initialized yet, this
|
||||
function will also set it.
|
||||
"""
|
||||
global USER_SITE
|
||||
user_base = getuserbase() # this will also set USER_BASE
|
||||
|
||||
if USER_SITE is not None:
|
||||
return USER_SITE
|
||||
|
||||
from sysconfig import get_path
|
||||
import os
|
||||
|
||||
if sys.platform == 'darwin':
|
||||
from sysconfig import get_config_var
|
||||
if get_config_var('PYTHONFRAMEWORK'):
|
||||
USER_SITE = get_path('purelib', 'osx_framework_user')
|
||||
return USER_SITE
|
||||
|
||||
USER_SITE = get_path('purelib', '%s_user' % os.name)
|
||||
return USER_SITE
|
||||
|
||||
def addusersitepackages(known_paths):
|
||||
"""Add a per user site-package to sys.path
|
||||
|
||||
Each user has its own python directory with site-packages in the
|
||||
home directory.
|
||||
"""
|
||||
# get the per user site-package path
|
||||
# this call will also make sure USER_BASE and USER_SITE are set
|
||||
user_site = getusersitepackages()
|
||||
|
||||
if ENABLE_USER_SITE and os.path.isdir(user_site):
|
||||
addsitedir(user_site, known_paths)
|
||||
return known_paths
|
||||
|
||||
def getsitepackages():
|
||||
"""Returns a list containing all global site-packages directories
|
||||
(and possibly site-python).
|
||||
|
||||
For each directory present in the global ``PREFIXES``, this function
|
||||
will find its `site-packages` subdirectory depending on the system
|
||||
environment, and will return a list of full paths.
|
||||
"""
|
||||
sitepackages = []
|
||||
seen = set()
|
||||
|
||||
for prefix in PREFIXES:
|
||||
if not prefix or prefix in seen:
|
||||
continue
|
||||
seen.add(prefix)
|
||||
|
||||
if sys.platform in ('os2emx', 'riscos'):
|
||||
sitepackages.append(os.path.join(prefix, "Lib", "site-packages"))
|
||||
elif os.sep == '/':
|
||||
sitepackages.append(os.path.join(prefix, "lib",
|
||||
"python" + sys.version[:3],
|
||||
"site-packages"))
|
||||
sitepackages.append(os.path.join(prefix, "lib", "site-python"))
|
||||
else:
|
||||
sitepackages.append(prefix)
|
||||
sitepackages.append(os.path.join(prefix, "lib", "site-packages"))
|
||||
if sys.platform == "darwin":
|
||||
# for framework builds *only* we add the standard Apple
|
||||
# locations.
|
||||
from sysconfig import get_config_var
|
||||
framework = get_config_var("PYTHONFRAMEWORK")
|
||||
if framework:
|
||||
sitepackages.append(
|
||||
os.path.join("/Library", framework,
|
||||
sys.version[:3], "site-packages"))
|
||||
return sitepackages
|
||||
|
||||
def addsitepackages(known_paths):
|
||||
"""Add site-packages (and possibly site-python) to sys.path"""
|
||||
for sitedir in getsitepackages():
|
||||
if os.path.isdir(sitedir):
|
||||
addsitedir(sitedir, known_paths)
|
||||
|
||||
return known_paths
|
||||
|
||||
def setBEGINLIBPATH():
|
||||
"""The OS/2 EMX port has optional extension modules that do double duty
|
||||
as DLLs (and must use the .DLL file extension) for other extensions.
|
||||
The library search path needs to be amended so these will be found
|
||||
during module import. Use BEGINLIBPATH so that these are at the start
|
||||
of the library search path.
|
||||
|
||||
"""
|
||||
dllpath = os.path.join(sys.prefix, "Lib", "lib-dynload")
|
||||
libpath = os.environ['BEGINLIBPATH'].split(';')
|
||||
if libpath[-1]:
|
||||
libpath.append(dllpath)
|
||||
else:
|
||||
libpath[-1] = dllpath
|
||||
os.environ['BEGINLIBPATH'] = ';'.join(libpath)
|
||||
|
||||
|
||||
def setquit():
|
||||
"""Define new builtins 'quit' and 'exit'.
|
||||
|
||||
These are objects which make the interpreter exit when called.
|
||||
The repr of each object contains a hint at how it works.
|
||||
|
||||
"""
|
||||
if os.sep == ':':
|
||||
eof = 'Cmd-Q'
|
||||
elif os.sep == '\\':
|
||||
eof = 'Ctrl-Z plus Return'
|
||||
else:
|
||||
eof = 'Ctrl-D (i.e. EOF)'
|
||||
|
||||
class Quitter(object):
|
||||
def __init__(self, name):
|
||||
self.name = name
|
||||
def __repr__(self):
|
||||
return 'Use %s() or %s to exit' % (self.name, eof)
|
||||
def __call__(self, code=None):
|
||||
# Shells like IDLE catch the SystemExit, but listen when their
|
||||
# stdin wrapper is closed.
|
||||
try:
|
||||
sys.stdin.close()
|
||||
except:
|
||||
pass
|
||||
raise SystemExit(code)
|
||||
__builtin__.quit = Quitter('quit')
|
||||
__builtin__.exit = Quitter('exit')
|
||||
|
||||
|
||||
class _Printer(object):
|
||||
"""interactive prompt objects for printing the license text, a list of
|
||||
contributors and the copyright notice."""
|
||||
|
||||
MAXLINES = 23
|
||||
|
||||
def __init__(self, name, data, files=(), dirs=()):
|
||||
self.__name = name
|
||||
self.__data = data
|
||||
self.__files = files
|
||||
self.__dirs = dirs
|
||||
self.__lines = None
|
||||
|
||||
def __setup(self):
|
||||
if self.__lines:
|
||||
return
|
||||
data = None
|
||||
for dir in self.__dirs:
|
||||
for filename in self.__files:
|
||||
filename = os.path.join(dir, filename)
|
||||
try:
|
||||
fp = file(filename, "rU")
|
||||
data = fp.read()
|
||||
fp.close()
|
||||
break
|
||||
except IOError:
|
||||
pass
|
||||
if data:
|
||||
break
|
||||
if not data:
|
||||
data = self.__data
|
||||
self.__lines = data.split('\n')
|
||||
self.__linecnt = len(self.__lines)
|
||||
|
||||
def __repr__(self):
|
||||
self.__setup()
|
||||
if len(self.__lines) <= self.MAXLINES:
|
||||
return "\n".join(self.__lines)
|
||||
else:
|
||||
return "Type %s() to see the full %s text" % ((self.__name,)*2)
|
||||
|
||||
def __call__(self):
|
||||
self.__setup()
|
||||
prompt = 'Hit Return for more, or q (and Return) to quit: '
|
||||
lineno = 0
|
||||
while 1:
|
||||
try:
|
||||
for i in range(lineno, lineno + self.MAXLINES):
|
||||
print self.__lines[i]
|
||||
except IndexError:
|
||||
break
|
||||
else:
|
||||
lineno += self.MAXLINES
|
||||
key = None
|
||||
while key is None:
|
||||
key = raw_input(prompt)
|
||||
if key not in ('', 'q'):
|
||||
key = None
|
||||
if key == 'q':
|
||||
break
|
||||
|
||||
def setcopyright():
|
||||
"""Set 'copyright' and 'credits' in __builtin__"""
|
||||
__builtin__.copyright = _Printer("copyright", sys.copyright)
|
||||
if sys.platform[:4] == 'java':
|
||||
__builtin__.credits = _Printer(
|
||||
"credits",
|
||||
"Jython is maintained by the Jython developers (www.jython.org).")
|
||||
else:
|
||||
__builtin__.credits = _Printer("credits", """\
|
||||
Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
|
||||
for supporting Python development. See www.python.org for more information.""")
|
||||
here = os.path.dirname(os.__file__)
|
||||
__builtin__.license = _Printer(
|
||||
"license", "See https://www.python.org/psf/license/",
|
||||
["LICENSE.txt", "LICENSE"],
|
||||
[os.path.join(here, os.pardir), here, os.curdir])
|
||||
|
||||
|
||||
class _Helper(object):
|
||||
"""Define the builtin 'help'.
|
||||
This is a wrapper around pydoc.help (with a twist).
|
||||
|
||||
"""
|
||||
|
||||
def __repr__(self):
|
||||
return "Type help() for interactive help, " \
|
||||
"or help(object) for help about object."
|
||||
def __call__(self, *args, **kwds):
|
||||
import pydoc
|
||||
return pydoc.help(*args, **kwds)
|
||||
|
||||
def sethelper():
|
||||
__builtin__.help = _Helper()
|
||||
|
||||
def aliasmbcs():
|
||||
"""On Windows, some default encodings are not provided by Python,
|
||||
while they are always available as "mbcs" in each locale. Make
|
||||
them usable by aliasing to "mbcs" in such a case."""
|
||||
if sys.platform == 'win32':
|
||||
import locale, codecs
|
||||
enc = locale.getdefaultlocale()[1]
|
||||
if enc.startswith('cp'): # "cp***" ?
|
||||
try:
|
||||
codecs.lookup(enc)
|
||||
except LookupError:
|
||||
import encodings
|
||||
encodings._cache[enc] = encodings._unknown
|
||||
encodings.aliases.aliases[enc] = 'mbcs'
|
||||
|
||||
def setencoding():
|
||||
"""Set the string encoding used by the Unicode implementation. The
|
||||
default is 'ascii', but if you're willing to experiment, you can
|
||||
change this."""
|
||||
encoding = "ascii" # Default value set by _PyUnicode_Init()
|
||||
if 0:
|
||||
# Enable to support locale aware default string encodings.
|
||||
import locale
|
||||
loc = locale.getdefaultlocale()
|
||||
if loc[1]:
|
||||
encoding = loc[1]
|
||||
if 0:
|
||||
# Enable to switch off string to Unicode coercion and implicit
|
||||
# Unicode to string conversion.
|
||||
encoding = "undefined"
|
||||
if encoding != "ascii":
|
||||
# On Non-Unicode builds this will raise an AttributeError...
|
||||
sys.setdefaultencoding(encoding) # Needs Python Unicode build !
|
||||
|
||||
|
||||
def execsitecustomize():
|
||||
"""Run custom site specific code, if available."""
|
||||
try:
|
||||
import sitecustomize
|
||||
except ImportError:
|
||||
pass
|
||||
except Exception:
|
||||
if sys.flags.verbose:
|
||||
sys.excepthook(*sys.exc_info())
|
||||
else:
|
||||
print >>sys.stderr, \
|
||||
"'import sitecustomize' failed; use -v for traceback"
|
||||
|
||||
|
||||
def execusercustomize():
|
||||
"""Run custom user specific code, if available."""
|
||||
try:
|
||||
import usercustomize
|
||||
except ImportError:
|
||||
pass
|
||||
except Exception:
|
||||
if sys.flags.verbose:
|
||||
sys.excepthook(*sys.exc_info())
|
||||
else:
|
||||
print>>sys.stderr, \
|
||||
"'import usercustomize' failed; use -v for traceback"
|
||||
|
||||
|
||||
def main():
|
||||
global ENABLE_USER_SITE
|
||||
|
||||
abs__file__()
|
||||
known_paths = removeduppaths()
|
||||
if ENABLE_USER_SITE is None:
|
||||
ENABLE_USER_SITE = check_enableusersite()
|
||||
known_paths = addusersitepackages(known_paths)
|
||||
known_paths = addsitepackages(known_paths)
|
||||
if sys.platform == 'os2emx':
|
||||
setBEGINLIBPATH()
|
||||
setquit()
|
||||
setcopyright()
|
||||
sethelper()
|
||||
aliasmbcs()
|
||||
setencoding()
|
||||
execsitecustomize()
|
||||
if ENABLE_USER_SITE:
|
||||
execusercustomize()
|
||||
# Remove sys.setdefaultencoding() so that users cannot change the
|
||||
# encoding after initialization. The test for presence is needed when
|
||||
# this module is run as a script, because this code is executed twice.
|
||||
if hasattr(sys, "setdefaultencoding"):
|
||||
del sys.setdefaultencoding
|
||||
|
||||
main()
|
||||
|
||||
def _script():
|
||||
help = """\
|
||||
%s [--user-base] [--user-site]
|
||||
|
||||
Without arguments print some useful information
|
||||
With arguments print the value of USER_BASE and/or USER_SITE separated
|
||||
by '%s'.
|
||||
|
||||
Exit codes with --user-base or --user-site:
|
||||
0 - user site directory is enabled
|
||||
1 - user site directory is disabled by user
|
||||
2 - uses site directory is disabled by super user
|
||||
or for security reasons
|
||||
>2 - unknown error
|
||||
"""
|
||||
args = sys.argv[1:]
|
||||
if not args:
|
||||
print "sys.path = ["
|
||||
for dir in sys.path:
|
||||
print " %r," % (dir,)
|
||||
print "]"
|
||||
print "USER_BASE: %r (%s)" % (USER_BASE,
|
||||
"exists" if os.path.isdir(USER_BASE) else "doesn't exist")
|
||||
print "USER_SITE: %r (%s)" % (USER_SITE,
|
||||
"exists" if os.path.isdir(USER_SITE) else "doesn't exist")
|
||||
print "ENABLE_USER_SITE: %r" % ENABLE_USER_SITE
|
||||
sys.exit(0)
|
||||
|
||||
buffer = []
|
||||
if '--user-base' in args:
|
||||
buffer.append(USER_BASE)
|
||||
if '--user-site' in args:
|
||||
buffer.append(USER_SITE)
|
||||
|
||||
if buffer:
|
||||
print os.pathsep.join(buffer)
|
||||
if ENABLE_USER_SITE:
|
||||
sys.exit(0)
|
||||
elif ENABLE_USER_SITE is False:
|
||||
sys.exit(1)
|
||||
elif ENABLE_USER_SITE is None:
|
||||
sys.exit(2)
|
||||
else:
|
||||
sys.exit(3)
|
||||
else:
|
||||
import textwrap
|
||||
print textwrap.dedent(help % (sys.argv[0], os.pathsep))
|
||||
sys.exit(10)
|
||||
|
||||
if __name__ == '__main__':
|
||||
_script()
|
Reference in New Issue
Block a user