wxPython/distutils/util.py

   1 """distutils.util
   2
   3 Miscellaneous utility functions -- anything that doesn't fit into
   4 one of the other *util.py modules.
   5 """
   6
   7 __revision__ = "$Id$"
   8
   9 import sys, os, string, re
  10 from distutils.errors import DistutilsPlatformError
  11 from distutils.dep_util import newer
  12 from distutils.spawn import spawn
  13 from distutils import log
  14
  15 def get_platform ():
  16     """Return a string that identifies the current platform.  This is used
  17     mainly to distinguish platform-specific build directories and
  18     platform-specific built distributions.  Typically includes the OS name
  19     and version and the architecture (as supplied by 'os.uname()'),
  20     although the exact information included depends on the OS; eg. for IRIX
  21     the architecture isn't particularly important (IRIX only runs on SGI
  22     hardware), but for Linux the kernel version isn't particularly
  23     important.
  24
  25     Examples of returned values:
  26        linux-i586
  27        linux-alpha (?)
  28        solaris-2.6-sun4u
  29        irix-5.3
  30        irix64-6.2
  31
  32     For non-POSIX platforms, currently just returns 'sys.platform'.
  33     """
  34     if os.name != "posix" or not hasattr(os, 'uname'):
  35         # XXX what about the architecture? NT is Intel or Alpha,
  36         # Mac OS is M68k or PPC, etc.
  37         return sys.platform
  38
  39     # Try to distinguish various flavours of Unix
  40
  41     (osname, host, release, version, machine) = os.uname()
  42
  43     # Convert the OS name to lowercase, remove '/' characters
  44     # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
  45     osname = string.lower(osname)
  46     osname = string.replace(osname, '/', '')
  47     machine = string.replace(machine, ' ', '_')
  48
  49     if osname[:5] == "linux":
  50         # At least on Linux/Intel, 'machine' is the processor --
  51         # i386, etc.
  52         # XXX what about Alpha, SPARC, etc?
  53         return  "%s-%s" % (osname, machine)
  54     elif osname[:5] == "sunos":
  55         if release[0] >= "5":           # SunOS 5 == Solaris 2
  56             osname = "solaris"
  57             release = "%d.%s" % (int(release[0]) - 3, release[2:])
  58         # fall through to standard osname-release-machine representation
  59     elif osname[:4] == "irix":              # could be "irix64"!
  60         return "%s-%s" % (osname, release)
  61     elif osname[:3] == "aix":
  62         return "%s-%s.%s" % (osname, version, release)
  63     elif osname[:6] == "cygwin":
  64         osname = "cygwin"
  65         rel_re = re.compile (r'[\d.]+')
  66         m = rel_re.match(release)
  67         if m:
  68             release = m.group()
  69
  70     return "%s-%s-%s" % (osname, release, machine)
  71
  72 # get_platform ()
  73
  74
  75 def convert_path (pathname):
  76     """Return 'pathname' as a name that will work on the native filesystem,
  77     i.e. split it on '/' and put it back together again using the current
  78     directory separator.  Needed because filenames in the setup script are
  79     always supplied in Unix style, and have to be converted to the local
  80     convention before we can actually use them in the filesystem.  Raises
  81     ValueError on non-Unix-ish systems if 'pathname' either starts or
  82     ends with a slash.
  83     """
  84     if os.sep == '/':
  85         return pathname
  86     if not pathname:
  87         return pathname
  88     if pathname[0] == '/':
  89         raise ValueError, "path '%s' cannot be absolute" % pathname
  90     if pathname[-1] == '/':
  91         raise ValueError, "path '%s' cannot end with '/'" % pathname
  92
  93     paths = string.split(pathname, '/')
  94     while '.' in paths:
  95         paths.remove('.')
  96     if not paths:
  97         return os.curdir
  98     return apply(os.path.join, paths)
  99
 100 # convert_path ()
 101
 102
 103 def change_root (new_root, pathname):
 104     """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
 105     relative, this is equivalent to "os.path.join(new_root,pathname)".
 106     Otherwise, it requires making 'pathname' relative and then joining the
 107     two, which is tricky on DOS/Windows and Mac OS.
 108     """
 109     if os.name == 'posix':
 110         if not os.path.isabs(pathname):
 111             return os.path.join(new_root, pathname)
 112         else:
 113             return os.path.join(new_root, pathname[1:])
 114
 115     elif os.name == 'nt':
 116         (drive, path) = os.path.splitdrive(pathname)
 117         if path[0] == '\\':
 118             path = path[1:]
 119         return os.path.join(new_root, path)
 120
 121     elif os.name == 'os2':
 122         (drive, path) = os.path.splitdrive(pathname)
 123         if path[0] == os.sep:
 124             path = path[1:]
 125         return os.path.join(new_root, path)
 126
 127     elif os.name == 'mac':
 128         if not os.path.isabs(pathname):
 129             return os.path.join(new_root, pathname)
 130         else:
 131             # Chop off volume name from start of path
 132             elements = string.split(pathname, ":", 1)
 133             pathname = ":" + elements[1]
 134             return os.path.join(new_root, pathname)
 135
 136     else:
 137         raise DistutilsPlatformError, \
 138               "nothing known about platform '%s'" % os.name
 139
 140
 141 _environ_checked = 0
 142 def check_environ ():
 143     """Ensure that 'os.environ' has all the environment variables we
 144     guarantee that users can use in config files, command-line options,
 145     etc.  Currently this includes:
 146       HOME - user's home directory (Unix only)
 147       PLAT - description of the current platform, including hardware
 148              and OS (see 'get_platform()')
 149     """
 150     global _environ_checked
 151     if _environ_checked:
 152         return
 153
 154     if os.name == 'posix' and not os.environ.has_key('HOME'):
 155         import pwd
 156         os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
 157
 158     if not os.environ.has_key('PLAT'):
 159         os.environ['PLAT'] = get_platform()
 160
 161     _environ_checked = 1
 162
 163
 164 def subst_vars (s, local_vars):
 165     """Perform shell/Perl-style variable substitution on 'string'.  Every
 166     occurrence of '$' followed by a name is considered a variable, and
 167     variable is substituted by the value found in the 'local_vars'
 168     dictionary, or in 'os.environ' if it's not in 'local_vars'.
 169     'os.environ' is first checked/augmented to guarantee that it contains
 170     certain values: see 'check_environ()'.  Raise ValueError for any
 171     variables not found in either 'local_vars' or 'os.environ'.
 172     """
 173     check_environ()
 174     def _subst (match, local_vars=local_vars):
 175         var_name = match.group(1)
 176         if local_vars.has_key(var_name):
 177             return str(local_vars[var_name])
 178         else:
 179             return os.environ[var_name]
 180
 181     try:
 182         return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
 183     except KeyError, var:
 184         raise ValueError, "invalid variable '$%s'" % var
 185
 186 # subst_vars ()
 187
 188
 189 def grok_environment_error (exc, prefix="error: "):
 190     """Generate a useful error message from an EnvironmentError (IOError or
 191     OSError) exception object.  Handles Python 1.5.1 and 1.5.2 styles, and
 192     does what it can to deal with exception objects that don't have a
 193     filename (which happens when the error is due to a two-file operation,
 194     such as 'rename()' or 'link()'.  Returns the error message as a string
 195     prefixed with 'prefix'.
 196     """
 197     # check for Python 1.5.2-style {IO,OS}Error exception objects
 198     if hasattr(exc, 'filename') and hasattr(exc, 'strerror'):
 199         if exc.filename:
 200             error = prefix + "%s: %s" % (exc.filename, exc.strerror)
 201         else:
 202             # two-argument functions in posix module don't
 203             # include the filename in the exception object!
 204             error = prefix + "%s" % exc.strerror
 205     else:
 206         error = prefix + str(exc[-1])
 207
 208     return error
 209
 210
 211 # Needed by 'split_quoted()'
 212 _wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
 213 _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
 214 _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')
 215
 216 def split_quoted (s):
 217     """Split a string up according to Unix shell-like rules for quotes and
 218     backslashes.  In short: words are delimited by spaces, as long as those
 219     spaces are not escaped by a backslash, or inside a quoted string.
 220     Single and double quotes are equivalent, and the quote characters can
 221     be backslash-escaped.  The backslash is stripped from any two-character
 222     escape sequence, leaving only the escaped character.  The quote
 223     characters are stripped from any quoted string.  Returns a list of
 224     words.
 225     """
 226
 227     # This is a nice algorithm for splitting up a single string, since it
 228     # doesn't require character-by-character examination.  It was a little
 229     # bit of a brain-bender to get it working right, though...
 230
 231     s = string.strip(s)
 232     words = []
 233     pos = 0
 234
 235     while s:
 236         m = _wordchars_re.match(s, pos)
 237         end = m.end()
 238         if end == len(s):
 239             words.append(s[:end])
 240             break
 241
 242         if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
 243             words.append(s[:end])       # we definitely have a word delimiter
 244             s = string.lstrip(s[end:])
 245             pos = 0
 246
 247         elif s[end] == '\\':            # preserve whatever is being escaped;
 248                                         # will become part of the current word
 249             s = s[:end] + s[end+1:]
 250             pos = end+1
 251
 252         else:
 253             if s[end] == "'":           # slurp singly-quoted string
 254                 m = _squote_re.match(s, end)
 255             elif s[end] == '"':         # slurp doubly-quoted string
 256                 m = _dquote_re.match(s, end)
 257             else:
 258                 raise RuntimeError, \
 259                       "this can't happen (bad char '%c')" % s[end]
 260
 261             if m is None:
 262                 raise ValueError, \
 263                       "bad string (mismatched %s quotes?)" % s[end]
 264
 265             (beg, end) = m.span()
 266             s = s[:beg] + s[beg+1:end-1] + s[end:]
 267             pos = m.end() - 2
 268
 269         if pos >= len(s):
 270             words.append(s)
 271             break
 272
 273     return words
 274
 275 # split_quoted ()
 276
 277
 278 def execute (func, args, msg=None, verbose=0, dry_run=0):
 279     """Perform some action that affects the outside world (eg.  by
 280     writing to the filesystem).  Such actions are special because they
 281     are disabled by the 'dry_run' flag.  This method takes care of all
 282     that bureaucracy for you; all you have to do is supply the
 283     function to call and an argument tuple for it (to embody the
 284     "external action" being performed), and an optional message to
 285     print.
 286     """
 287     if msg is None:
 288         msg = "%s%s" % (func.__name__, `args`)
 289         if msg[-2:] == ',)':        # correct for singleton tuple
 290             msg = msg[0:-2] + ')'
 291
 292     log.info(msg)
 293     if not dry_run:
 294         apply(func, args)
 295
 296
 297 def strtobool (val):
 298     """Convert a string representation of truth to true (1) or false (0).
 299
 300     True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
 301     are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
 302     'val' is anything else.
 303     """
 304     val = string.lower(val)
 305     if val in ('y', 'yes', 't', 'true', 'on', '1'):
 306         return 1
 307     elif val in ('n', 'no', 'f', 'false', 'off', '0'):
 308         return 0
 309     else:
 310         raise ValueError, "invalid truth value %s" % `val`
 311
 312
 313 def byte_compile (py_files,
 314                   optimize=0, force=0,
 315                   prefix=None, base_dir=None,
 316                   verbose=1, dry_run=0,
 317                   direct=None):
 318     """Byte-compile a collection of Python source files to either .pyc
 319     or .pyo files in the same directory.  'py_files' is a list of files
 320     to compile; any files that don't end in ".py" are silently skipped.
 321     'optimize' must be one of the following:
 322       0 - don't optimize (generate .pyc)
 323       1 - normal optimization (like "python -O")
 324       2 - extra optimization (like "python -OO")
 325     If 'force' is true, all files are recompiled regardless of
 326     timestamps.
 327
 328     The source filename encoded in each bytecode file defaults to the
 329     filenames listed in 'py_files'; you can modify these with 'prefix' and
 330     'basedir'.  'prefix' is a string that will be stripped off of each
 331     source filename, and 'base_dir' is a directory name that will be
 332     prepended (after 'prefix' is stripped).  You can supply either or both
 333     (or neither) of 'prefix' and 'base_dir', as you wish.
 334
 335     If 'dry_run' is true, doesn't actually do anything that would
 336     affect the filesystem.
 337
 338     Byte-compilation is either done directly in this interpreter process
 339     with the standard py_compile module, or indirectly by writing a
 340     temporary script and executing it.  Normally, you should let
 341     'byte_compile()' figure out to use direct compilation or not (see
 342     the source for details).  The 'direct' flag is used by the script
 343     generated in indirect mode; unless you know what you're doing, leave
 344     it set to None.
 345     """
 346
 347     # First, if the caller didn't force us into direct or indirect mode,
 348     # figure out which mode we should be in.  We take a conservative
 349     # approach: choose direct mode *only* if the current interpreter is
 350     # in debug mode and optimize is 0.  If we're not in debug mode (-O
 351     # or -OO), we don't know which level of optimization this
 352     # interpreter is running with, so we can't do direct
 353     # byte-compilation and be certain that it's the right thing.  Thus,
 354     # always compile indirectly if the current interpreter is in either
 355     # optimize mode, or if either optimization level was requested by
 356     # the caller.
 357     if direct is None:
 358         direct = (__debug__ and optimize == 0)
 359
 360     # "Indirect" byte-compilation: write a temporary script and then
 361     # run it with the appropriate flags.
 362     if not direct:
 363         try:
 364             from tempfile import mkstemp
 365             (script_fd, script_name) = mkstemp(".py")
 366         except ImportError:
 367             from tempfile import mktemp
 368             (script_fd, script_name) = None, mktemp(".py")
 369         log.info("writing byte-compilation script '%s'", script_name)
 370         if not dry_run:
 371             if script_fd is not None:
 372                 script = os.fdopen(script_fd, "w")
 373             else:
 374                 script = open(script_name, "w")
 375
 376             script.write("""\
 377 from distutils.util import byte_compile
 378 files = [
 379 """)
 380
 381             # XXX would be nice to write absolute filenames, just for
 382             # safety's sake (script should be more robust in the face of
 383             # chdir'ing before running it).  But this requires abspath'ing
 384             # 'prefix' as well, and that breaks the hack in build_lib's
 385             # 'byte_compile()' method that carefully tacks on a trailing
 386             # slash (os.sep really) to make sure the prefix here is "just
 387             # right".  This whole prefix business is rather delicate -- the
 388             # problem is that it's really a directory, but I'm treating it
 389             # as a dumb string, so trailing slashes and so forth matter.
 390
 391             #py_files = map(os.path.abspath, py_files)
 392             #if prefix:
 393             #    prefix = os.path.abspath(prefix)
 394
 395             script.write(string.join(map(repr, py_files), ",\n") + "]\n")
 396             script.write("""
 397 byte_compile(files, optimize=%s, force=%s,
 398              prefix=%s, base_dir=%s,
 399              verbose=%s, dry_run=0,
 400              direct=1)
 401 """ % (`optimize`, `force`, `prefix`, `base_dir`, `verbose`))
 402
 403             script.close()
 404
 405         cmd = [sys.executable, script_name]
 406         if optimize == 1:
 407             cmd.insert(1, "-O")
 408         elif optimize == 2:
 409             cmd.insert(1, "-OO")
 410         spawn(cmd, dry_run=dry_run)
 411         execute(os.remove, (script_name,), "removing %s" % script_name,
 412                 dry_run=dry_run)
 413
 414     # "Direct" byte-compilation: use the py_compile module to compile
 415     # right here, right now.  Note that the script generated in indirect
 416     # mode simply calls 'byte_compile()' in direct mode, a weird sort of
 417     # cross-process recursion.  Hey, it works!
 418     else:
 419         from py_compile import compile
 420
 421         for file in py_files:
 422             if file[-3:] != ".py":
 423                 # This lets us be lazy and not filter filenames in
 424                 # the "install_lib" command.
 425                 continue
 426
 427             # Terminology from the py_compile module:
 428             #   cfile - byte-compiled file
 429             #   dfile - purported source filename (same as 'file' by default)
 430             cfile = file + (__debug__ and "c" or "o")
 431             dfile = file
 432             if prefix:
 433                 if file[:len(prefix)] != prefix:
 434                     raise ValueError, \
 435                           ("invalid prefix: filename %s doesn't start with %s"
 436                            % (`file`, `prefix`))
 437                 dfile = dfile[len(prefix):]
 438             if base_dir:
 439                 dfile = os.path.join(base_dir, dfile)
 440
 441             cfile_base = os.path.basename(cfile)
 442             if direct:
 443                 if force or newer(file, cfile):
 444                     log.info("byte-compiling %s to %s", file, cfile_base)
 445                     if not dry_run:
 446                         compile(file, cfile, dfile)
 447                 else:
 448                     log.debug("skipping byte-compilation of %s to %s",
 449                               file, cfile_base)
 450
 451 # byte_compile ()
 452
 453 def rfc822_escape (header):
 454     """Return a version of the string escaped for inclusion in an
 455     RFC-822 header, by ensuring there are 8 spaces space after each newline.
 456     """
 457     lines = string.split(header, '\n')
 458     lines = map(string.strip, lines)
 459     header = string.join(lines, '\n' + 8*' ')
 460     return header