Lib/platform.py

   1 #!/usr/bin/env python
   2
   3 """ This module tries to retrieve as much platform-identifying data as
   4     possible. It makes this information available via function APIs.
   5
   6     If called from the command line, it prints the platform
   7     information concatenated as single string to stdout. The output
   8     format is useable as part of a filename.
   9
  10 """
  11 #    This module is maintained by Marc-Andre Lemburg <mal@egenix.com>.
  12 #    If you find problems, please submit bug reports/patches via the
  13 #    Python bug tracker (http://bugs.python.org) and assign them to "lemburg".
  14 #
  15 #    Note: Please keep this module compatible to Python 1.5.2.
  16 #
  17 #    Still needed:
  18 #    * more support for WinCE
  19 #    * support for MS-DOS (PythonDX ?)
  20 #    * support for Amiga and other still unsupported platforms running Python
  21 #    * support for additional Linux distributions
  22 #
  23 #    Many thanks to all those who helped adding platform-specific
  24 #    checks (in no particular order):
  25 #
  26 #      Charles G Waldman, David Arnold, Gordon McMillan, Ben Darnell,
  27 #      Jeff Bauer, Cliff Crawford, Ivan Van Laningham, Josef
  28 #      Betancourt, Randall Hopper, Karl Putland, John Farrell, Greg
  29 #      Andruk, Just van Rossum, Thomas Heller, Mark R. Levinson, Mark
  30 #      Hammond, Bill Tutt, Hans Nowak, Uwe Zessin (OpenVMS support),
  31 #      Colin Kong, Trent Mick, Guido van Rossum, Anthony Baxter
  32 #
  33 #    History:
  34 #
  35 #    <see CVS and SVN checkin messages for history>
  36 #
  37 #    1.0.7 - added DEV_NULL
  38 #    1.0.6 - added linux_distribution()
  39 #    1.0.5 - fixed Java support to allow running the module on Jython
  40 #    1.0.4 - added IronPython support
  41 #    1.0.3 - added normalization of Windows system name
  42 #    1.0.2 - added more Windows support
  43 #    1.0.1 - reformatted to make doc.py happy
  44 #    1.0.0 - reformatted a bit and checked into Python CVS
  45 #    0.8.0 - added sys.version parser and various new access
  46 #            APIs (python_version(), python_compiler(), etc.)
  47 #    0.7.2 - fixed architecture() to use sizeof(pointer) where available
  48 #    0.7.1 - added support for Caldera OpenLinux
  49 #    0.7.0 - some fixes for WinCE; untabified the source file
  50 #    0.6.2 - support for OpenVMS - requires version 1.5.2-V006 or higher and
  51 #            vms_lib.getsyi() configured
  52 #    0.6.1 - added code to prevent 'uname -p' on platforms which are
  53 #            known not to support it
  54 #    0.6.0 - fixed win32_ver() to hopefully work on Win95,98,NT and Win2k;
  55 #            did some cleanup of the interfaces - some APIs have changed
  56 #    0.5.5 - fixed another type in the MacOS code... should have
  57 #            used more coffee today ;-)
  58 #    0.5.4 - fixed a few typos in the MacOS code
  59 #    0.5.3 - added experimental MacOS support; added better popen()
  60 #            workarounds in _syscmd_ver() -- still not 100% elegant
  61 #            though
  62 #    0.5.2 - fixed uname() to return '' instead of 'unknown' in all
  63 #            return values (the system uname command tends to return
  64 #            'unknown' instead of just leaving the field emtpy)
  65 #    0.5.1 - included code for slackware dist; added exception handlers
  66 #            to cover up situations where platforms don't have os.popen
  67 #            (e.g. Mac) or fail on socket.gethostname(); fixed libc
  68 #            detection RE
  69 #    0.5.0 - changed the API names referring to system commands to *syscmd*;
  70 #            added java_ver(); made syscmd_ver() a private
  71 #            API (was system_ver() in previous versions) -- use uname()
  72 #            instead; extended the win32_ver() to also return processor
  73 #            type information
  74 #    0.4.0 - added win32_ver() and modified the platform() output for WinXX
  75 #    0.3.4 - fixed a bug in _follow_symlinks()
  76 #    0.3.3 - fixed popen() and "file" command invokation bugs
  77 #    0.3.2 - added architecture() API and support for it in platform()
  78 #    0.3.1 - fixed syscmd_ver() RE to support Windows NT
  79 #    0.3.0 - added system alias support
  80 #    0.2.3 - removed 'wince' again... oh well.
  81 #    0.2.2 - added 'wince' to syscmd_ver() supported platforms
  82 #    0.2.1 - added cache logic and changed the platform string format
  83 #    0.2.0 - changed the API to use functions instead of module globals
  84 #            since some action take too long to be run on module import
  85 #    0.1.0 - first release
  86 #
  87 #    You can always get the latest version of this module at:
  88 #
  89 #             http://www.egenix.com/files/python/platform.py
  90 #
  91 #    If that URL should fail, try contacting the author.
  92
  93 __copyright__ = """
  94     Copyright (c) 1999-2000, Marc-Andre Lemburg; mailto:mal@lemburg.com
  95     Copyright (c) 2000-2009, eGenix.com Software GmbH; mailto:info@egenix.com
  96
  97     Permission to use, copy, modify, and distribute this software and its
  98     documentation for any purpose and without fee or royalty is hereby granted,
  99     provided that the above copyright notice appear in all copies and that
 100     both that copyright notice and this permission notice appear in
 101     supporting documentation or portions thereof, including modifications,
 102     that you make.
 103
 104     EGENIX.COM SOFTWARE GMBH DISCLAIMS ALL WARRANTIES WITH REGARD TO
 105     THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 106     FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
 107     INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
 108     FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 109     NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 110     WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !
 111
 112 """
 113
 114 __version__ = '1.0.7'
 115
 116 import sys,string,os,re
 117
 118 ### Globals & Constants
 119
 120 # Determine the platform's /dev/null device
 121 try:
 122     DEV_NULL = os.devnull
 123 except AttributeError:
 124     # os.devnull was added in Python 2.4, so emulate it for earlier
 125     # Python versions
 126     if sys.platform in ('dos','win32','win16','os2'):
 127         # Use the old CP/M NUL as device name
 128         DEV_NULL = 'NUL'
 129     else:
 130         # Standard Unix uses /dev/null
 131         DEV_NULL = '/dev/null'
 132
 133 ### Platform specific APIs
 134
 135 _libc_search = re.compile(r'(__libc_init)'
 136                           '|'
 137                           '(GLIBC_([0-9.]+))'
 138                           '|'
 139                           '(libc(_\w+)?\.so(?:\.(\d[0-9.]*))?)')
 140
 141 def libc_ver(executable=sys.executable,lib='',version='',
 142
 143              chunksize=2048):
 144
 145     """ Tries to determine the libc version that the file executable
 146         (which defaults to the Python interpreter) is linked against.
 147
 148         Returns a tuple of strings (lib,version) which default to the
 149         given parameters in case the lookup fails.
 150
 151         Note that the function has intimate knowledge of how different
 152         libc versions add symbols to the executable and thus is probably
 153         only useable for executables compiled using gcc.
 154
 155         The file is read and scanned in chunks of chunksize bytes.
 156
 157     """
 158     if hasattr(os.path, 'realpath'):
 159         # Python 2.2 introduced os.path.realpath(); it is used
 160         # here to work around problems with Cygwin not being
 161         # able to open symlinks for reading
 162         executable = os.path.realpath(executable)
 163     f = open(executable,'rb')
 164     binary = f.read(chunksize)
 165     pos = 0
 166     while 1:
 167         m = _libc_search.search(binary,pos)
 168         if not m:
 169             binary = f.read(chunksize)
 170             if not binary:
 171                 break
 172             pos = 0
 173             continue
 174         libcinit,glibc,glibcversion,so,threads,soversion = m.groups()
 175         if libcinit and not lib:
 176             lib = 'libc'
 177         elif glibc:
 178             if lib != 'glibc':
 179                 lib = 'glibc'
 180                 version = glibcversion
 181             elif glibcversion > version:
 182                 version = glibcversion
 183         elif so:
 184             if lib != 'glibc':
 185                 lib = 'libc'
 186                 if soversion > version:
 187                     version = soversion
 188                 if threads and version[-len(threads):] != threads:
 189                     version = version + threads
 190         pos = m.end()
 191     f.close()
 192     return lib,version
 193
 194 def _dist_try_harder(distname,version,id):
 195
 196     """ Tries some special tricks to get the distribution
 197         information in case the default method fails.
 198
 199         Currently supports older SuSE Linux, Caldera OpenLinux and
 200         Slackware Linux distributions.
 201
 202     """
 203     if os.path.exists('/var/adm/inst-log/info'):
 204         # SuSE Linux stores distribution information in that file
 205         info = open('/var/adm/inst-log/info').readlines()
 206         distname = 'SuSE'
 207         for line in info:
 208             tv = string.split(line)
 209             if len(tv) == 2:
 210                 tag,value = tv
 211             else:
 212                 continue
 213             if tag == 'MIN_DIST_VERSION':
 214                 version = string.strip(value)
 215             elif tag == 'DIST_IDENT':
 216                 values = string.split(value,'-')
 217                 id = values[2]
 218         return distname,version,id
 219
 220     if os.path.exists('/etc/.installed'):
 221         # Caldera OpenLinux has some infos in that file (thanks to Colin Kong)
 222         info = open('/etc/.installed').readlines()
 223         for line in info:
 224             pkg = string.split(line,'-')
 225             if len(pkg) >= 2 and pkg[0] == 'OpenLinux':
 226                 # XXX does Caldera support non Intel platforms ? If yes,
 227                 #     where can we find the needed id ?
 228                 return 'OpenLinux',pkg[1],id
 229
 230     if os.path.isdir('/usr/lib/setup'):
 231         # Check for slackware verson tag file (thanks to Greg Andruk)
 232         verfiles = os.listdir('/usr/lib/setup')
 233         for n in range(len(verfiles)-1, -1, -1):
 234             if verfiles[n][:14] != 'slack-version-':
 235                 del verfiles[n]
 236         if verfiles:
 237             verfiles.sort()
 238             distname = 'slackware'
 239             version = verfiles[-1][14:]
 240             return distname,version,id
 241
 242     return distname,version,id
 243
 244 _release_filename = re.compile(r'(\w+)[-_](release|version)')
 245 _lsb_release_version = re.compile(r'(.+)'
 246                                    ' release '
 247                                    '([\d.]+)'
 248                                    '[^(]*(?:\((.+)\))?')
 249 _release_version = re.compile(r'([^0-9]+)'
 250                                '(?: release )?'
 251                                '([\d.]+)'
 252                                '[^(]*(?:\((.+)\))?')
 253
 254 # See also http://www.novell.com/coolsolutions/feature/11251.html
 255 # and http://linuxmafia.com/faq/Admin/release-files.html
 256 # and http://data.linux-ntfs.org/rpm/whichrpm
 257 # and http://www.die.net/doc/linux/man/man1/lsb_release.1.html
 258
 259 _supported_dists = (
 260     'SuSE', 'debian', 'fedora', 'redhat', 'centos',
 261     'mandrake', 'mandriva', 'rocks', 'slackware', 'yellowdog', 'gentoo',
 262     'UnitedLinux', 'turbolinux')
 263
 264 def _parse_release_file(firstline):
 265
 266     # Parse the first line
 267     m = _lsb_release_version.match(firstline)
 268     if m is not None:
 269         # LSB format: "distro release x.x (codename)"
 270         return tuple(m.groups())
 271
 272     # Pre-LSB format: "distro x.x (codename)"
 273     m = _release_version.match(firstline)
 274     if m is not None:
 275         return tuple(m.groups())
 276
 277     # Unkown format... take the first two words
 278     l = string.split(string.strip(firstline))
 279     if l:
 280         version = l[0]
 281         if len(l) > 1:
 282             id = l[1]
 283         else:
 284             id = ''
 285     return '', version, id
 286
 287 def linux_distribution(distname='', version='', id='',
 288
 289                        supported_dists=_supported_dists,
 290                        full_distribution_name=1):
 291
 292     """ Tries to determine the name of the Linux OS distribution name.
 293
 294         The function first looks for a distribution release file in
 295         /etc and then reverts to _dist_try_harder() in case no
 296         suitable files are found.
 297
 298         supported_dists may be given to define the set of Linux
 299         distributions to look for. It defaults to a list of currently
 300         supported Linux distributions identified by their release file
 301         name.
 302
 303         If full_distribution_name is true (default), the full
 304         distribution read from the OS is returned. Otherwise the short
 305         name taken from supported_dists is used.
 306
 307         Returns a tuple (distname,version,id) which default to the
 308         args given as parameters.
 309
 310     """
 311     try:
 312         etc = os.listdir('/etc')
 313     except os.error:
 314         # Probably not a Unix system
 315         return distname,version,id
 316     etc.sort()
 317     for file in etc:
 318         m = _release_filename.match(file)
 319         if m is not None:
 320             _distname,dummy = m.groups()
 321             if _distname in supported_dists:
 322                 distname = _distname
 323                 break
 324     else:
 325         return _dist_try_harder(distname,version,id)
 326
 327     # Read the first line
 328     f = open('/etc/'+file, 'r')
 329     firstline = f.readline()
 330     f.close()
 331     _distname, _version, _id = _parse_release_file(firstline)
 332
 333     if _distname and full_distribution_name:
 334         distname = _distname
 335     if _version:
 336         version = _version
 337     if _id:
 338         id = _id
 339     return distname, version, id
 340
 341 # To maintain backwards compatibility:
 342
 343 def dist(distname='',version='',id='',
 344
 345          supported_dists=_supported_dists):
 346
 347     """ Tries to determine the name of the Linux OS distribution name.
 348
 349         The function first looks for a distribution release file in
 350         /etc and then reverts to _dist_try_harder() in case no
 351         suitable files are found.
 352
 353         Returns a tuple (distname,version,id) which default to the
 354         args given as parameters.
 355
 356     """
 357     return linux_distribution(distname, version, id,
 358                               supported_dists=supported_dists,
 359                               full_distribution_name=0)
 360
 361 class _popen:
 362
 363     """ Fairly portable (alternative) popen implementation.
 364
 365         This is mostly needed in case os.popen() is not available, or
 366         doesn't work as advertised, e.g. in Win9X GUI programs like
 367         PythonWin or IDLE.
 368
 369         Writing to the pipe is currently not supported.
 370
 371     """
 372     tmpfile = ''
 373     pipe = None
 374     bufsize = None
 375     mode = 'r'
 376
 377     def __init__(self,cmd,mode='r',bufsize=None):
 378
 379         if mode != 'r':
 380             raise ValueError,'popen()-emulation only supports read mode'
 381         import tempfile
 382         self.tmpfile = tmpfile = tempfile.mktemp()
 383         os.system(cmd + ' > %s' % tmpfile)
 384         self.pipe = open(tmpfile,'rb')
 385         self.bufsize = bufsize
 386         self.mode = mode
 387
 388     def read(self):
 389
 390         return self.pipe.read()
 391
 392     def readlines(self):
 393
 394         if self.bufsize is not None:
 395             return self.pipe.readlines()
 396
 397     def close(self,
 398
 399               remove=os.unlink,error=os.error):
 400
 401         if self.pipe:
 402             rc = self.pipe.close()
 403         else:
 404             rc = 255
 405         if self.tmpfile:
 406             try:
 407                 remove(self.tmpfile)
 408             except error:
 409                 pass
 410         return rc
 411
 412     # Alias
 413     __del__ = close
 414
 415 def popen(cmd, mode='r', bufsize=None):
 416
 417     """ Portable popen() interface.
 418     """
 419     # Find a working popen implementation preferring win32pipe.popen
 420     # over os.popen over _popen
 421     popen = None
 422     if os.environ.get('OS','') == 'Windows_NT':
 423         # On NT win32pipe should work; on Win9x it hangs due to bugs
 424         # in the MS C lib (see MS KnowledgeBase article Q150956)
 425         try:
 426             import win32pipe
 427         except ImportError:
 428             pass
 429         else:
 430             popen = win32pipe.popen
 431     if popen is None:
 432         if hasattr(os,'popen'):
 433             popen = os.popen
 434             # Check whether it works... it doesn't in GUI programs
 435             # on Windows platforms
 436             if sys.platform == 'win32': # XXX Others too ?
 437                 try:
 438                     popen('')
 439                 except os.error:
 440                     popen = _popen
 441         else:
 442             popen = _popen
 443     if bufsize is None:
 444         return popen(cmd,mode)
 445     else:
 446         return popen(cmd,mode,bufsize)
 447
 448 def _norm_version(version, build=''):
 449
 450     """ Normalize the version and build strings and return a single
 451         version string using the format major.minor.build (or patchlevel).
 452     """
 453     l = string.split(version,'.')
 454     if build:
 455         l.append(build)
 456     try:
 457         ints = map(int,l)
 458     except ValueError:
 459         strings = l
 460     else:
 461         strings = map(str,ints)
 462     version = string.join(strings[:3],'.')
 463     return version
 464
 465 _ver_output = re.compile(r'(?:([\w ]+) ([\w.]+) '
 466                          '.*'
 467                          '\[.* ([\d.]+)\])')
 468
 469 # Examples of VER command output:
 470 #
 471 #   Windows 2000:  Microsoft Windows 2000 [Version 5.00.2195]
 472 #   Windows XP:    Microsoft Windows XP [Version 5.1.2600]
 473 #   Windows Vista: Microsoft Windows [Version 6.0.6002]
 474 #
 475 # Note that the "Version" string gets localized on different
 476 # Windows versions.
 477
 478 def _syscmd_ver(system='', release='', version='',
 479
 480                supported_platforms=('win32','win16','dos','os2')):
 481
 482     """ Tries to figure out the OS version used and returns
 483         a tuple (system,release,version).
 484
 485         It uses the "ver" shell command for this which is known
 486         to exists on Windows, DOS and OS/2. XXX Others too ?
 487
 488         In case this fails, the given parameters are used as
 489         defaults.
 490
 491     """
 492     if sys.platform not in supported_platforms:
 493         return system,release,version
 494
 495     # Try some common cmd strings
 496     for cmd in ('ver','command /c ver','cmd /c ver'):
 497         try:
 498             pipe = popen(cmd)
 499             info = pipe.read()
 500             if pipe.close():
 501                 raise os.error,'command failed'
 502             # XXX How can I supress shell errors from being written
 503             #     to stderr ?
 504         except os.error,why:
 505             #print 'Command %s failed: %s' % (cmd,why)
 506             continue
 507         except IOError,why:
 508             #print 'Command %s failed: %s' % (cmd,why)
 509             continue
 510         else:
 511             break
 512     else:
 513         return system,release,version
 514
 515     # Parse the output
 516     info = string.strip(info)
 517     m = _ver_output.match(info)
 518     if m is not None:
 519         system,release,version = m.groups()
 520         # Strip trailing dots from version and release
 521         if release[-1] == '.':
 522             release = release[:-1]
 523         if version[-1] == '.':
 524             version = version[:-1]
 525         # Normalize the version and build strings (eliminating additional
 526         # zeros)
 527         version = _norm_version(version)
 528     return system,release,version
 529
 530 def _win32_getvalue(key,name,default=''):
 531
 532     """ Read a value for name from the registry key.
 533
 534         In case this fails, default is returned.
 535
 536     """
 537     try:
 538         # Use win32api if available
 539         from win32api import RegQueryValueEx
 540     except ImportError:
 541         # On Python 2.0 and later, emulate using _winreg
 542         import _winreg
 543         RegQueryValueEx = _winreg.QueryValueEx
 544     try:
 545         return RegQueryValueEx(key,name)
 546     except:
 547         return default
 548
 549 def win32_ver(release='',version='',csd='',ptype=''):
 550
 551     """ Get additional version information from the Windows Registry
 552         and return a tuple (version,csd,ptype) referring to version
 553         number, CSD level and OS type (multi/single
 554         processor).
 555
 556         As a hint: ptype returns 'Uniprocessor Free' on single
 557         processor NT machines and 'Multiprocessor Free' on multi
 558         processor machines. The 'Free' refers to the OS version being
 559         free of debugging code. It could also state 'Checked' which
 560         means the OS version uses debugging code, i.e. code that
 561         checks arguments, ranges, etc. (Thomas Heller).
 562
 563         Note: this function works best with Mark Hammond's win32
 564         package installed, but also on Python 2.3 and later. It
 565         obviously only runs on Win32 compatible platforms.
 566
 567     """
 568     # XXX Is there any way to find out the processor type on WinXX ?
 569     # XXX Is win32 available on Windows CE ?
 570     #
 571     # Adapted from code posted by Karl Putland to comp.lang.python.
 572     #
 573     # The mappings between reg. values and release names can be found
 574     # here: http://msdn.microsoft.com/library/en-us/sysinfo/base/osversioninfo_str.asp
 575
 576     # Import the needed APIs
 577     try:
 578         import win32api
 579         from win32api import RegQueryValueEx, RegOpenKeyEx, \
 580              RegCloseKey, GetVersionEx
 581         from win32con import HKEY_LOCAL_MACHINE, VER_PLATFORM_WIN32_NT, \
 582              VER_PLATFORM_WIN32_WINDOWS, VER_NT_WORKSTATION
 583     except ImportError:
 584         # Emulate the win32api module using Python APIs
 585         try:
 586             sys.getwindowsversion
 587         except AttributeError:
 588             # No emulation possible, so return the defaults...
 589             return release,version,csd,ptype
 590         else:
 591             # Emulation using _winreg (added in Python 2.0) and
 592             # sys.getwindowsversion() (added in Python 2.3)
 593             import _winreg
 594             GetVersionEx = sys.getwindowsversion
 595             RegQueryValueEx = _winreg.QueryValueEx
 596             RegOpenKeyEx = _winreg.OpenKeyEx
 597             RegCloseKey = _winreg.CloseKey
 598             HKEY_LOCAL_MACHINE = _winreg.HKEY_LOCAL_MACHINE
 599             VER_PLATFORM_WIN32_WINDOWS = 1
 600             VER_PLATFORM_WIN32_NT = 2
 601             VER_NT_WORKSTATION = 1
 602
 603     # Find out the registry key and some general version infos
 604     maj,min,buildno,plat,csd = GetVersionEx()
 605     version = '%i.%i.%i' % (maj,min,buildno & 0xFFFF)
 606     if csd[:13] == 'Service Pack ':
 607         csd = 'SP' + csd[13:]
 608
 609     if plat == VER_PLATFORM_WIN32_WINDOWS:
 610         regkey = 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion'
 611         # Try to guess the release name
 612         if maj == 4:
 613             if min == 0:
 614                 release = '95'
 615             elif min == 10:
 616                 release = '98'
 617             elif min == 90:
 618                 release = 'Me'
 619             else:
 620                 release = 'postMe'
 621         elif maj == 5:
 622             release = '2000'
 623
 624     elif plat == VER_PLATFORM_WIN32_NT:
 625         regkey = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion'
 626         if maj <= 4:
 627             release = 'NT'
 628         elif maj == 5:
 629             if min == 0:
 630                 release = '2000'
 631             elif min == 1:
 632                 release = 'XP'
 633             elif min == 2:
 634                 release = '2003Server'
 635             else:
 636                 release = 'post2003'
 637         elif maj == 6:
 638             if min == 0:
 639                 # Per http://msdn2.microsoft.com/en-us/library/ms724429.aspx
 640                 try:
 641                     productType = GetVersionEx(1)[8]
 642                 except TypeError:
 643                     # sys.getwindowsversion() doesn't take any arguments, so
 644                     # we cannot detect 2008 Server that way.
 645                     # XXX Add some other means of detecting 2008 Server ?!
 646                     release = 'Vista'
 647                 else:
 648                     if productType == VER_NT_WORKSTATION:
 649                         release = 'Vista'
 650                     else:
 651                         release = '2008Server'
 652             #elif min == 1:
 653             #    # Windows 7 release candidate uses version 6.1.7100
 654             #    release = '7RC'
 655             else:
 656                 release = 'post2008Server'
 657
 658     else:
 659         if not release:
 660             # E.g. Win3.1 with win32s
 661             release = '%i.%i' % (maj,min)
 662         return release,version,csd,ptype
 663
 664     # Open the registry key
 665     try:
 666         keyCurVer = RegOpenKeyEx(HKEY_LOCAL_MACHINE, regkey)
 667         # Get a value to make sure the key exists...
 668         RegQueryValueEx(keyCurVer, 'SystemRoot')
 669     except:
 670         return release,version,csd,ptype
 671
 672     # Parse values
 673     #subversion = _win32_getvalue(keyCurVer,
 674     #                            'SubVersionNumber',
 675     #                            ('',1))[0]
 676     #if subversion:
 677     #   release = release + subversion # 95a, 95b, etc.
 678     build = _win32_getvalue(keyCurVer,
 679                             'CurrentBuildNumber',
 680                             ('',1))[0]
 681     ptype = _win32_getvalue(keyCurVer,
 682                            'CurrentType',
 683                            (ptype,1))[0]
 684
 685     # Normalize version
 686     version = _norm_version(version,build)
 687
 688     # Close key
 689     RegCloseKey(keyCurVer)
 690     return release,version,csd,ptype
 691
 692 def _mac_ver_lookup(selectors,default=None):
 693
 694     from gestalt import gestalt
 695     import MacOS
 696     l = []
 697     append = l.append
 698     for selector in selectors:
 699         try:
 700             append(gestalt(selector))
 701         except (RuntimeError, MacOS.Error):
 702             append(default)
 703     return l
 704
 705 def _bcd2str(bcd):
 706
 707     return hex(bcd)[2:]
 708
 709 def mac_ver(release='',versioninfo=('','',''),machine=''):
 710
 711     """ Get MacOS version information and return it as tuple (release,
 712         versioninfo, machine) with versioninfo being a tuple (version,
 713         dev_stage, non_release_version).
 714
 715         Entries which cannot be determined are set to the paramter values
 716         which default to ''. All tuple entries are strings.
 717
 718         Thanks to Mark R. Levinson for mailing documentation links and
 719         code examples for this function. Documentation for the
 720         gestalt() API is available online at:
 721
 722            http://www.rgaros.nl/gestalt/
 723
 724     """
 725     # Check whether the version info module is available
 726     try:
 727         import gestalt
 728         import MacOS
 729     except ImportError:
 730         return release,versioninfo,machine
 731     # Get the infos
 732     sysv,sysu,sysa = _mac_ver_lookup(('sysv','sysu','sysa'))
 733     # Decode the infos
 734     if sysv:
 735         major = (sysv & 0xFF00) >> 8
 736         minor = (sysv & 0x00F0) >> 4
 737         patch = (sysv & 0x000F)
 738
 739         if (major, minor) >= (10, 4):
 740             # the 'sysv' gestald cannot return patchlevels
 741             # higher than 9. Apple introduced 3 new
 742             # gestalt codes in 10.4 to deal with this
 743             # issue (needed because patch levels can
 744             # run higher than 9, such as 10.4.11)
 745             major,minor,patch = _mac_ver_lookup(('sys1','sys2','sys3'))
 746             release = '%i.%i.%i' %(major, minor, patch)
 747         else:
 748             release = '%s.%i.%i' % (_bcd2str(major),minor,patch)
 749
 750     if sysu:
 751         # NOTE: this block is left as documentation of the
 752         # intention of this function, the 'sysu' gestalt is no
 753         # longer available and there are no alternatives.
 754         major =  int((sysu & 0xFF000000L) >> 24)
 755         minor =  (sysu & 0x00F00000) >> 20
 756         bugfix = (sysu & 0x000F0000) >> 16
 757         stage =  (sysu & 0x0000FF00) >> 8
 758         nonrel = (sysu & 0x000000FF)
 759         version = '%s.%i.%i' % (_bcd2str(major),minor,bugfix)
 760         nonrel = _bcd2str(nonrel)
 761         stage = {0x20:'development',
 762                  0x40:'alpha',
 763                  0x60:'beta',
 764                  0x80:'final'}.get(stage,'')
 765         versioninfo = (version,stage,nonrel)
 766
 767
 768     if sysa:
 769         machine = {0x1: '68k',
 770                    0x2: 'PowerPC',
 771                    0xa: 'i386'}.get(sysa,'')
 772     return release,versioninfo,machine
 773
 774 def _java_getprop(name,default):
 775
 776     from java.lang import System
 777     try:
 778         value = System.getProperty(name)
 779         if value is None:
 780             return default
 781         return value
 782     except AttributeError:
 783         return default
 784
 785 def java_ver(release='',vendor='',vminfo=('','',''),osinfo=('','','')):
 786
 787     """ Version interface for Jython.
 788
 789         Returns a tuple (release,vendor,vminfo,osinfo) with vminfo being
 790         a tuple (vm_name,vm_release,vm_vendor) and osinfo being a
 791         tuple (os_name,os_version,os_arch).
 792
 793         Values which cannot be determined are set to the defaults
 794         given as parameters (which all default to '').
 795
 796     """
 797     # Import the needed APIs
 798     try:
 799         import java.lang
 800     except ImportError:
 801         return release,vendor,vminfo,osinfo
 802
 803     vendor = _java_getprop('java.vendor', vendor)
 804     release = _java_getprop('java.version', release)
 805     vm_name, vm_release, vm_vendor = vminfo
 806     vm_name = _java_getprop('java.vm.name', vm_name)
 807     vm_vendor = _java_getprop('java.vm.vendor', vm_vendor)
 808     vm_release = _java_getprop('java.vm.version', vm_release)
 809     vminfo = vm_name, vm_release, vm_vendor
 810     os_name, os_version, os_arch = osinfo
 811     os_arch = _java_getprop('java.os.arch', os_arch)
 812     os_name = _java_getprop('java.os.name', os_name)
 813     os_version = _java_getprop('java.os.version', os_version)
 814     osinfo = os_name, os_version, os_arch
 815
 816     return release, vendor, vminfo, osinfo
 817
 818 ### System name aliasing
 819
 820 def system_alias(system,release,version):
 821
 822     """ Returns (system,release,version) aliased to common
 823         marketing names used for some systems.
 824
 825         It also does some reordering of the information in some cases
 826         where it would otherwise cause confusion.
 827
 828     """
 829     if system == 'Rhapsody':
 830         # Apple's BSD derivative
 831         # XXX How can we determine the marketing release number ?
 832         return 'MacOS X Server',system+release,version
 833
 834     elif system == 'SunOS':
 835         # Sun's OS
 836         if release < '5':
 837             # These releases use the old name SunOS
 838             return system,release,version
 839         # Modify release (marketing release = SunOS release - 3)
 840         l = string.split(release,'.')
 841         if l:
 842             try:
 843                 major = int(l[0])
 844             except ValueError:
 845                 pass
 846             else:
 847                 major = major - 3
 848                 l[0] = str(major)
 849                 release = string.join(l,'.')
 850         if release < '6':
 851             system = 'Solaris'
 852         else:
 853             # XXX Whatever the new SunOS marketing name is...
 854             system = 'Solaris'
 855
 856     elif system == 'IRIX64':
 857         # IRIX reports IRIX64 on platforms with 64-bit support; yet it
 858         # is really a version and not a different platform, since 32-bit
 859         # apps are also supported..
 860         system = 'IRIX'
 861         if version:
 862             version = version + ' (64bit)'
 863         else:
 864             version = '64bit'
 865
 866     elif system in ('win32','win16'):
 867         # In case one of the other tricks
 868         system = 'Windows'
 869
 870     return system,release,version
 871
 872 ### Various internal helpers
 873
 874 def _platform(*args):
 875
 876     """ Helper to format the platform string in a filename
 877         compatible format e.g. "system-version-machine".
 878     """
 879     # Format the platform string
 880     platform = string.join(
 881         map(string.strip,
 882             filter(len, args)),
 883         '-')
 884
 885     # Cleanup some possible filename obstacles...
 886     replace = string.replace
 887     platform = replace(platform,' ','_')
 888     platform = replace(platform,'/','-')
 889     platform = replace(platform,'\\','-')
 890     platform = replace(platform,':','-')
 891     platform = replace(platform,';','-')
 892     platform = replace(platform,'"','-')
 893     platform = replace(platform,'(','-')
 894     platform = replace(platform,')','-')
 895
 896     # No need to report 'unknown' information...
 897     platform = replace(platform,'unknown','')
 898
 899     # Fold '--'s and remove trailing '-'
 900     while 1:
 901         cleaned = replace(platform,'--','-')
 902         if cleaned == platform:
 903             break
 904         platform = cleaned
 905     while platform[-1] == '-':
 906         platform = platform[:-1]
 907
 908     return platform
 909
 910 def _node(default=''):
 911
 912     """ Helper to determine the node name of this machine.
 913     """
 914     try:
 915         import socket
 916     except ImportError:
 917         # No sockets...
 918         return default
 919     try:
 920         return socket.gethostname()
 921     except socket.error:
 922         # Still not working...
 923         return default
 924
 925 # os.path.abspath is new in Python 1.5.2:
 926 if not hasattr(os.path,'abspath'):
 927
 928     def _abspath(path,
 929
 930                  isabs=os.path.isabs,join=os.path.join,getcwd=os.getcwd,
 931                  normpath=os.path.normpath):
 932
 933         if not isabs(path):
 934             path = join(getcwd(), path)
 935         return normpath(path)
 936
 937 else:
 938
 939     _abspath = os.path.abspath
 940
 941 def _follow_symlinks(filepath):
 942
 943     """ In case filepath is a symlink, follow it until a
 944         real file is reached.
 945     """
 946     filepath = _abspath(filepath)
 947     while os.path.islink(filepath):
 948         filepath = os.path.normpath(
 949             os.path.join(os.path.dirname(filepath),os.readlink(filepath)))
 950     return filepath
 951
 952 def _syscmd_uname(option,default=''):
 953
 954     """ Interface to the system's uname command.
 955     """
 956     if sys.platform in ('dos','win32','win16','os2'):
 957         # XXX Others too ?
 958         return default
 959     try:
 960         f = os.popen('uname %s 2> %s' % (option, DEV_NULL))
 961     except (AttributeError,os.error):
 962         return default
 963     output = string.strip(f.read())
 964     rc = f.close()
 965     if not output or rc:
 966         return default
 967     else:
 968         return output
 969
 970 def _syscmd_file(target,default=''):
 971
 972     """ Interface to the system's file command.
 973
 974         The function uses the -b option of the file command to have it
 975         ommit the filename in its output and if possible the -L option
 976         to have the command follow symlinks. It returns default in
 977         case the command should fail.
 978
 979     """
 980     if sys.platform in ('dos','win32','win16','os2'):
 981         # XXX Others too ?
 982         return default
 983     target = _follow_symlinks(target)
 984     try:
 985         f = os.popen('file "%s" 2> %s' % (target, DEV_NULL))
 986     except (AttributeError,os.error):
 987         return default
 988     output = string.strip(f.read())
 989     rc = f.close()
 990     if not output or rc:
 991         return default
 992     else:
 993         return output
 994
 995 ### Information about the used architecture
 996
 997 # Default values for architecture; non-empty strings override the
 998 # defaults given as parameters
 999 _default_architecture = {
1000     'win32': ('','WindowsPE'),
1001     'win16': ('','Windows'),
1002     'dos': ('','MSDOS'),
1003 }
1004
1005 _architecture_split = re.compile(r'[\s,]').split
1006
1007 def architecture(executable=sys.executable,bits='',linkage=''):
1008
1009     """ Queries the given executable (defaults to the Python interpreter
1010         binary) for various architecture information.
1011
1012         Returns a tuple (bits,linkage) which contains information about
1013         the bit architecture and the linkage format used for the
1014         executable. Both values are returned as strings.
1015
1016         Values that cannot be determined are returned as given by the
1017         parameter presets. If bits is given as '', the sizeof(pointer)
1018         (or sizeof(long) on Python version < 1.5.2) is used as
1019         indicator for the supported pointer size.
1020
1021         The function relies on the system's "file" command to do the
1022         actual work. This is available on most if not all Unix
1023         platforms. On some non-Unix platforms where the "file" command
1024         does not exist and the executable is set to the Python interpreter
1025         binary defaults from _default_architecture are used.
1026
1027     """
1028     # Use the sizeof(pointer) as default number of bits if nothing
1029     # else is given as default.
1030     if not bits:
1031         import struct
1032         try:
1033             size = struct.calcsize('P')
1034         except struct.error:
1035             # Older installations can only query longs
1036             size = struct.calcsize('l')
1037         bits = str(size*8) + 'bit'
1038
1039     # Get data from the 'file' system command
1040     if executable:
1041         output = _syscmd_file(executable, '')
1042     else:
1043         output = ''
1044
1045     if not output and \
1046        executable == sys.executable:
1047         # "file" command did not return anything; we'll try to provide
1048         # some sensible defaults then...
1049         if _default_architecture.has_key(sys.platform):
1050             b,l = _default_architecture[sys.platform]
1051             if b:
1052                 bits = b
1053             if l:
1054                 linkage = l
1055         return bits,linkage
1056
1057     # Split the output into a list of strings omitting the filename
1058     fileout = _architecture_split(output)[1:]
1059
1060     if 'executable' not in fileout:
1061         # Format not supported
1062         return bits,linkage
1063
1064     # Bits
1065     if '32-bit' in fileout:
1066         bits = '32bit'
1067     elif 'N32' in fileout:
1068         # On Irix only
1069         bits = 'n32bit'
1070     elif '64-bit' in fileout:
1071         bits = '64bit'
1072
1073     # Linkage
1074     if 'ELF' in fileout:
1075         linkage = 'ELF'
1076     elif 'PE' in fileout:
1077         # E.g. Windows uses this format
1078         if 'Windows' in fileout:
1079             linkage = 'WindowsPE'
1080         else:
1081             linkage = 'PE'
1082     elif 'COFF' in fileout:
1083         linkage = 'COFF'
1084     elif 'MS-DOS' in fileout:
1085         linkage = 'MSDOS'
1086     else:
1087         # XXX the A.OUT format also falls under this class...
1088         pass
1089
1090     return bits,linkage
1091
1092 ### Portable uname() interface
1093
1094 _uname_cache = None
1095
1096 def uname():
1097
1098     """ Fairly portable uname interface. Returns a tuple
1099         of strings (system,node,release,version,machine,processor)
1100         identifying the underlying platform.
1101
1102         Note that unlike the os.uname function this also returns
1103         possible processor information as an additional tuple entry.
1104
1105         Entries which cannot be determined are set to ''.
1106
1107     """
1108     global _uname_cache
1109     no_os_uname = 0
1110
1111     if _uname_cache is not None:
1112         return _uname_cache
1113
1114     processor = ''
1115
1116     # Get some infos from the builtin os.uname API...
1117     try:
1118         system,node,release,version,machine = os.uname()
1119     except AttributeError:
1120         no_os_uname = 1
1121
1122     if no_os_uname or not filter(None, (system, node, release, version, machine)):
1123         # Hmm, no there is either no uname or uname has returned
1124         #'unknowns'... we'll have to poke around the system then.
1125         if no_os_uname:
1126             system = sys.platform
1127             release = ''
1128             version = ''
1129             node = _node()
1130             machine = ''
1131
1132         use_syscmd_ver = 1
1133
1134         # Try win32_ver() on win32 platforms
1135         if system == 'win32':
1136             release,version,csd,ptype = win32_ver()
1137             if release and version:
1138                 use_syscmd_ver = 0
1139             # Try to use the PROCESSOR_* environment variables
1140             # available on Win XP and later; see
1141             # http://support.microsoft.com/kb/888731 and
1142             # http://www.geocities.com/rick_lively/MANUALS/ENV/MSWIN/PROCESSI.HTM
1143             if not machine:
1144                 machine = os.environ.get('PROCESSOR_ARCHITECTURE', '')
1145             if not processor:
1146                 processor = os.environ.get('PROCESSOR_IDENTIFIER', machine)
1147
1148         # Try the 'ver' system command available on some
1149         # platforms
1150         if use_syscmd_ver:
1151             system,release,version = _syscmd_ver(system)
1152             # Normalize system to what win32_ver() normally returns
1153             # (_syscmd_ver() tends to return the vendor name as well)
1154             if system == 'Microsoft Windows':
1155                 system = 'Windows'
1156             elif system == 'Microsoft' and release == 'Windows':
1157                 # Under Windows Vista and Windows Server 2008,
1158                 # Microsoft changed the output of the ver command. The
1159                 # release is no longer printed.  This causes the
1160                 # system and release to be misidentified.
1161                 system = 'Windows'
1162                 if '6.0' == version[:3]:
1163                     release = 'Vista'
1164                 else:
1165                     release = ''
1166
1167         # In case we still don't know anything useful, we'll try to
1168         # help ourselves
1169         if system in ('win32','win16'):
1170             if not version:
1171                 if system == 'win32':
1172                     version = '32bit'
1173                 else:
1174                     version = '16bit'
1175             system = 'Windows'
1176
1177         elif system[:4] == 'java':
1178             release,vendor,vminfo,osinfo = java_ver()
1179             system = 'Java'
1180             version = string.join(vminfo,', ')
1181             if not version:
1182                 version = vendor
1183
1184         elif os.name == 'mac':
1185             release,(version,stage,nonrel),machine = mac_ver()
1186             system = 'MacOS'
1187
1188     # System specific extensions
1189     if system == 'OpenVMS':
1190         # OpenVMS seems to have release and version mixed up
1191         if not release or release == '0':
1192             release = version
1193             version = ''
1194         # Get processor information
1195         try:
1196             import vms_lib
1197         except ImportError:
1198             pass
1199         else:
1200             csid, cpu_number = vms_lib.getsyi('SYI$_CPU',0)
1201             if (cpu_number >= 128):
1202                 processor = 'Alpha'
1203             else:
1204                 processor = 'VAX'
1205     if not processor:
1206         # Get processor information from the uname system command
1207         processor = _syscmd_uname('-p','')
1208
1209     #If any unknowns still exist, replace them with ''s, which are more portable
1210     if system == 'unknown':
1211         system = ''
1212     if node == 'unknown':
1213         node = ''
1214     if release == 'unknown':
1215         release = ''
1216     if version == 'unknown':
1217         version = ''
1218     if machine == 'unknown':
1219         machine = ''
1220     if processor == 'unknown':
1221         processor = ''
1222
1223     #  normalize name
1224     if system == 'Microsoft' and release == 'Windows':
1225         system = 'Windows'
1226         release = 'Vista'
1227
1228     _uname_cache = system,node,release,version,machine,processor
1229     return _uname_cache
1230
1231 ### Direct interfaces to some of the uname() return values
1232
1233 def system():
1234
1235     """ Returns the system/OS name, e.g. 'Linux', 'Windows' or 'Java'.
1236
1237         An empty string is returned if the value cannot be determined.
1238
1239     """
1240     return uname()[0]
1241
1242 def node():
1243
1244     """ Returns the computer's network name (which may not be fully
1245         qualified)
1246
1247         An empty string is returned if the value cannot be determined.
1248
1249     """
1250     return uname()[1]
1251
1252 def release():
1253
1254     """ Returns the system's release, e.g. '2.2.0' or 'NT'
1255
1256         An empty string is returned if the value cannot be determined.
1257
1258     """
1259     return uname()[2]
1260
1261 def version():
1262
1263     """ Returns the system's release version, e.g. '#3 on degas'
1264
1265         An empty string is returned if the value cannot be determined.
1266
1267     """
1268     return uname()[3]
1269
1270 def machine():
1271
1272     """ Returns the machine type, e.g. 'i386'
1273
1274         An empty string is returned if the value cannot be determined.
1275
1276     """
1277     return uname()[4]
1278
1279 def processor():
1280
1281     """ Returns the (true) processor name, e.g. 'amdk6'
1282
1283         An empty string is returned if the value cannot be
1284         determined. Note that many platforms do not provide this
1285         information or simply return the same value as for machine(),
1286         e.g.  NetBSD does this.
1287
1288     """
1289     return uname()[5]
1290
1291 ### Various APIs for extracting information from sys.version
1292
1293 _sys_version_parser = re.compile(
1294     r'([\w.+]+)\s*'
1295     '\(#?([^,]+),\s*([\w ]+),\s*([\w :]+)\)\s*'
1296     '\[([^\]]+)\]?')
1297
1298 _ironpython_sys_version_parser = re.compile(
1299     r'IronPython\s*'
1300     '([\d\.]+)'
1301     '(?: \(([\d\.]+)\))?'
1302     ' on (.NET [\d\.]+)')
1303
1304 _pypy_sys_version_parser = re.compile(
1305     r'([\w.+]+)\s*'
1306     '\(#?([^,]+),\s*([\w ]+),\s*([\w :]+)\)\s*'
1307     '\[PyPy [^\]]+\]?')
1308
1309 _sys_version_cache = {}
1310
1311 def _sys_version(sys_version=None):
1312
1313     """ Returns a parsed version of Python's sys.version as tuple
1314         (name, version, branch, revision, buildno, builddate, compiler)
1315         referring to the Python implementation name, version, branch,
1316         revision, build number, build date/time as string and the compiler
1317         identification string.
1318
1319         Note that unlike the Python sys.version, the returned value
1320         for the Python version will always include the patchlevel (it
1321         defaults to '.0').
1322
1323         The function returns empty strings for tuple entries that
1324         cannot be determined.
1325
1326         sys_version may be given to parse an alternative version
1327         string, e.g. if the version was read from a different Python
1328         interpreter.
1329
1330     """
1331     # Get the Python version
1332     if sys_version is None:
1333         sys_version = sys.version
1334
1335     # Try the cache first
1336     result = _sys_version_cache.get(sys_version, None)
1337     if result is not None:
1338         return result
1339
1340     # Parse it
1341     if sys_version[:10] == 'IronPython':
1342         # IronPython
1343         name = 'IronPython'
1344         match = _ironpython_sys_version_parser.match(sys_version)
1345         if match is None:
1346             raise ValueError(
1347                 'failed to parse IronPython sys.version: %s' %
1348                 repr(sys_version))
1349         version, alt_version, compiler = match.groups()
1350         buildno = ''
1351         builddate = ''
1352
1353     elif sys.platform[:4] == 'java':
1354         # Jython
1355         name = 'Jython'
1356         match = _sys_version_parser.match(sys_version)
1357         if match is None:
1358             raise ValueError(
1359                 'failed to parse Jython sys.version: %s' %
1360                 repr(sys_version))
1361         version, buildno, builddate, buildtime, _ = match.groups()
1362         compiler = sys.platform
1363
1364     elif "PyPy" in sys_version:
1365         # PyPy
1366         name = "PyPy"
1367         match = _pypy_sys_version_parser.match(sys_version)
1368         if match is None:
1369             raise ValueError("failed to parse PyPy sys.version: %s" %
1370                              repr(sys_version))
1371         version, buildno, builddate, buildtime = match.groups()
1372         compiler = ""
1373
1374     else:
1375         # CPython
1376         match = _sys_version_parser.match(sys_version)
1377         if match is None:
1378             raise ValueError(
1379                 'failed to parse CPython sys.version: %s' %
1380                 repr(sys_version))
1381         version, buildno, builddate, buildtime, compiler = \
1382               match.groups()
1383         name = 'CPython'
1384         builddate = builddate + ' ' + buildtime
1385
1386     if hasattr(sys, 'subversion'):
1387         # sys.subversion was added in Python 2.5
1388         _, branch, revision = sys.subversion
1389     else:
1390         branch = ''
1391         revision = ''
1392
1393     # Add the patchlevel version if missing
1394     l = string.split(version, '.')
1395     if len(l) == 2:
1396         l.append('0')
1397         version = string.join(l, '.')
1398
1399     # Build and cache the result
1400     result = (name, version, branch, revision, buildno, builddate, compiler)
1401     _sys_version_cache[sys_version] = result
1402     return result
1403
1404 def python_implementation():
1405
1406     """ Returns a string identifying the Python implementation.
1407
1408         Currently, the following implementations are identified:
1409         'CPython' (C implementation of Python),
1410         'IronPython' (.NET implementation of Python),
1411         'Jython' (Java implementation of Python).
1412
1413     """
1414     return _sys_version()[0]
1415
1416 def python_version():
1417
1418     """ Returns the Python version as string 'major.minor.patchlevel'
1419
1420         Note that unlike the Python sys.version, the returned value
1421         will always include the patchlevel (it defaults to 0).
1422
1423     """
1424     return _sys_version()[1]
1425
1426 def python_version_tuple():
1427
1428     """ Returns the Python version as tuple (major, minor, patchlevel)
1429         of strings.
1430
1431         Note that unlike the Python sys.version, the returned value
1432         will always include the patchlevel (it defaults to 0).
1433
1434     """
1435     return tuple(string.split(_sys_version()[1], '.'))
1436
1437 def python_branch():
1438
1439     """ Returns a string identifying the Python implementation
1440         branch.
1441
1442         For CPython this is the Subversion branch from which the
1443         Python binary was built.
1444
1445         If not available, an empty string is returned.
1446
1447     """
1448
1449     return _sys_version()[2]
1450
1451 def python_revision():
1452
1453     """ Returns a string identifying the Python implementation
1454         revision.
1455
1456         For CPython this is the Subversion revision from which the
1457         Python binary was built.
1458
1459         If not available, an empty string is returned.
1460
1461     """
1462     return _sys_version()[3]
1463
1464 def python_build():
1465
1466     """ Returns a tuple (buildno, builddate) stating the Python
1467         build number and date as strings.
1468
1469     """
1470     return _sys_version()[4:6]
1471
1472 def python_compiler():
1473
1474     """ Returns a string identifying the compiler used for compiling
1475         Python.
1476
1477     """
1478     return _sys_version()[6]
1479
1480 ### The Opus Magnum of platform strings :-)
1481
1482 _platform_cache = {}
1483
1484 def platform(aliased=0, terse=0):
1485
1486     """ Returns a single string identifying the underlying platform
1487         with as much useful information as possible (but no more :).
1488
1489         The output is intended to be human readable rather than
1490         machine parseable. It may look different on different
1491         platforms and this is intended.
1492
1493         If "aliased" is true, the function will use aliases for
1494         various platforms that report system names which differ from
1495         their common names, e.g. SunOS will be reported as
1496         Solaris. The system_alias() function is used to implement
1497         this.
1498
1499         Setting terse to true causes the function to return only the
1500         absolute minimum information needed to identify the platform.
1501
1502     """
1503     result = _platform_cache.get((aliased, terse), None)
1504     if result is not None:
1505         return result
1506
1507     # Get uname information and then apply platform specific cosmetics
1508     # to it...
1509     system,node,release,version,machine,processor = uname()
1510     if machine == processor:
1511         processor = ''
1512     if aliased:
1513         system,release,version = system_alias(system,release,version)
1514
1515     if system == 'Windows':
1516         # MS platforms
1517         rel,vers,csd,ptype = win32_ver(version)
1518         if terse:
1519             platform = _platform(system,release)
1520         else:
1521             platform = _platform(system,release,version,csd)
1522
1523     elif system in ('Linux',):
1524         # Linux based systems
1525         distname,distversion,distid = dist('')
1526         if distname and not terse:
1527             platform = _platform(system,release,machine,processor,
1528                                  'with',
1529                                  distname,distversion,distid)
1530         else:
1531             # If the distribution name is unknown check for libc vs. glibc
1532             libcname,libcversion = libc_ver(sys.executable)
1533             platform = _platform(system,release,machine,processor,
1534                                  'with',
1535                                  libcname+libcversion)
1536     elif system == 'Java':
1537         # Java platforms
1538         r,v,vminfo,(os_name,os_version,os_arch) = java_ver()
1539         if terse or not os_name:
1540             platform = _platform(system,release,version)
1541         else:
1542             platform = _platform(system,release,version,
1543                                  'on',
1544                                  os_name,os_version,os_arch)
1545
1546     elif system == 'MacOS':
1547         # MacOS platforms
1548         if terse:
1549             platform = _platform(system,release)
1550         else:
1551             platform = _platform(system,release,machine)
1552
1553     else:
1554         # Generic handler
1555         if terse:
1556             platform = _platform(system,release)
1557         else:
1558             bits,linkage = architecture(sys.executable)
1559             platform = _platform(system,release,machine,processor,bits,linkage)
1560
1561     _platform_cache[(aliased, terse)] = platform
1562     return platform
1563
1564 ### Command line interface
1565
1566 if __name__ == '__main__':
1567     # Default is to print the aliased verbose platform string
1568     terse = ('terse' in sys.argv or '--terse' in sys.argv)
1569     aliased = (not 'nonaliased' in sys.argv and not '--nonaliased' in sys.argv)
1570     print platform(aliased,terse)
1571     sys.exit(0)