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