# any string not found in this dict, will get 0 assigned

'dev': 10,

'alpha': 20, 'a': 20,

'beta': 30, 'b': 30,

'c': 40,

'RC': 50, 'rc': 50,

# number, will get 100 assigned

'pl': 200, 'p': 200,

result = []

for v in _component_re.split(version):

if v not in '._+-':

try:

v = int(v, 10)

t = 100

except ValueError:

t = _ver_stages.get(v, 0)

result.extend((t, v))

'|'

'(GLIBC_([0-9.]+))'

'|'

""" Tries to determine the libc version that the file executable

V = _comparable_version

if hasattr(os.path, 'realpath'):

# Python 2.2 introduced os.path.realpath(); it is used

# here to work around problems with Cygwin not being

# able to open symlinks for reading

executable = os.path.realpath(executable)

with open(executable, 'rb') as f:

binary = f.read(chunksize)

pos = 0

while pos < len(binary):

if 'libc' in binary or 'GLIBC' in binary:

m = _libc_search.search(binary, pos)

else:

m = None

if not m or m.end() == len(binary):

chunk = f.read(chunksize)

if chunk:

binary = binary[max(pos, len(binary) - 1000):] + chunk

pos = 0

continue

if not m:

break

libcinit,glibc,glibcversion,so,threads,soversion = m.groups()

if libcinit and not lib:

lib = 'libc'

elif glibc:

if lib != 'glibc':

lib = 'glibc'

version = glibcversion

elif V(glibcversion) > V(version):

version = glibcversion

elif so:

if lib != 'glibc':

lib = 'libc'

if soversion and (not version or V(soversion) > V(version)):

version = soversion

if threads and version[-len(threads):] != threads:

version = version + threads

pos = m.end()

""" Tries some special tricks to get the distribution

if os.path.exists('/var/adm/inst-log/info'):

# SuSE Linux stores distribution information in that file

info = open('/var/adm/inst-log/info').readlines()

distname = 'SuSE'

for line in info:

tv = string.split(line)

if len(tv) == 2:

tag,value = tv

else:

continue

if tag == 'MIN_DIST_VERSION':

version = string.strip(value)

elif tag == 'DIST_IDENT':

values = string.split(value,'-')

id = values[2]

return distname,version,id

if os.path.exists('/etc/.installed'):

# Caldera OpenLinux has some infos in that file (thanks to Colin Kong)

info = open('/etc/.installed').readlines()

for line in info:

pkg = string.split(line,'-')

if len(pkg) >= 2 and pkg[0] == 'OpenLinux':

# XXX does Caldera support non Intel platforms ? If yes,

# where can we find the needed id ?

return 'OpenLinux',pkg[1],id

if os.path.isdir('/usr/lib/setup'):

# Check for slackware version tag file (thanks to Greg Andruk)

verfiles = os.listdir('/usr/lib/setup')

for n in range(len(verfiles)-1, -1, -1):

if verfiles[n][:14] != 'slack-version-':

del verfiles[n]

if verfiles:

verfiles.sort()

distname = 'slackware'

version = verfiles[-1][14:]

return distname,version,id

# Default to empty 'version' and 'id' strings. Both defaults are used

# when 'firstline' is empty. 'id' defaults to empty when an id can not

# be deduced.

version = ''

id = ''

# Parse the first line

m = _lsb_release_version.match(firstline)

if m is not None:

# LSB format: "distro release x.x (codename)"

return tuple(m.groups())

# Pre-LSB format: "distro x.x (codename)"

m = _release_version.match(firstline)

if m is not None:

return tuple(m.groups())

# Unknown format... take the first two words

l = string.split(string.strip(firstline))

if l:

version = l[0]

if len(l) > 1:

id = l[1]

supported_dists=_supported_dists,

full_distribution_name=1):

""" Tries to determine the name of the Linux OS distribution name.

try:

etc = os.listdir('/etc')

except os.error:

# Probably not a Unix system

return distname,version,id

etc.sort()

for file in etc:

m = _release_filename.match(file)

if m is not None:

_distname,dummy = m.groups()

if _distname in supported_dists:

distname = _distname

break

else:

return _dist_try_harder(distname,version,id)

# Read the first line

f = open('/etc/'+file, 'r')

firstline = f.readline()

f.close()

_distname, _version, _id = _parse_release_file(firstline)

if _distname and full_distribution_name:

distname = _distname

if _version:

version = _version

if _id:

id = _id

supported_dists=_supported_dists):

""" Tries to determine the name of the Linux OS distribution name.

return linux_distribution(distname, version, id,

supported_dists=supported_dists,

""" Fairly portable (alternative) popen implementation.

tmpfile = ''

pipe = None

bufsize = None

mode = 'r'

def __init__(self,cmd,mode='r',bufsize=None):

if mode != 'r':

raise ValueError,'popen()-emulation only supports read mode'

import tempfile

self.tmpfile = tmpfile = tempfile.mktemp()

os.system(cmd + ' > %s' % tmpfile)

self.pipe = open(tmpfile,'rb')

self.bufsize = bufsize

self.mode = mode

def read(self):

return self.pipe.read()

def readlines(self):

if self.bufsize is not None:

return self.pipe.readlines()

def close(self,

remove=os.unlink,error=os.error):

if self.pipe:

rc = self.pipe.close()

else:

rc = 255

if self.tmpfile:

try:

remove(self.tmpfile)

except error:

pass

return rc

# Alias

""" Portable popen() interface.

# Find a working popen implementation preferring win32pipe.popen

# over os.popen over _popen

popen = None

if os.environ.get('OS','') == 'Windows_NT':

# On NT win32pipe should work; on Win9x it hangs due to bugs

# in the MS C lib (see MS KnowledgeBase article Q150956)

try:

import win32pipe

except ImportError:

pass

else:

popen = win32pipe.popen

if popen is None:

if hasattr(os,'popen'):

popen = os.popen

# Check whether it works... it doesn't in GUI programs

# on Windows platforms

if sys.platform == 'win32': # XXX Others too ?

try:

popen('')

except os.error:

popen = _popen

else:

popen = _popen

if bufsize is None:

return popen(cmd,mode)

else:

""" Normalize the version and build strings and return a single

l = string.split(version,'.')

if build:

l.append(build)

try:

ints = map(int,l)

except ValueError:

strings = l

else:

strings = map(str,ints)

version = string.join(strings[:3],'.')

supported_platforms=('win32','win16','dos','os2')):

""" Tries to figure out the OS version used and returns

if sys.platform not in supported_platforms:

return system,release,version

# Try some common cmd strings

for cmd in ('ver','command /c ver','cmd /c ver'):

try:

pipe = popen(cmd)

info = pipe.read()

if pipe.close():

raise os.error,'command failed'

# XXX How can I suppress shell errors from being written

# to stderr ?

except os.error,why:

#print 'Command %s failed: %s' % (cmd,why)

continue

except IOError,why:

#print 'Command %s failed: %s' % (cmd,why)

continue

else:

break

else:

return system,release,version

# Parse the output

info = string.strip(info)

m = _ver_output.match(info)

if m is not None:

system,release,version = m.groups()

# Strip trailing dots from version and release

if release[-1] == '.':

release = release[:-1]

if version[-1] == '.':

version = version[:-1]

# Normalize the version and build strings (eliminating additional

# zeros)

version = _norm_version(version)

(5, 0): "2000",

(5, 1): "XP",

# Strictly, 5.2 client is XP 64-bit, but platform.py historically

# has always called it 2003 Server

(5, 2): "2003Server",

(5, None): "post2003",

(6, 0): "Vista",

(6, 1): "7",

(6, 2): "8",

(6, 3): "8.1",

(6, None): "post8.1",

(10, 0): "10",

(10, None): "post10",

(5, 2): "2003Server",

(6, 0): "2008Server",

(6, 1): "2008ServerR2",

(6, 2): "2012Server",

(6, 3): "2012ServerR2",

(6, None): "post2012ServerR2",

if maj < 6 or (maj == 6 and min < 2):

return maj, min, build

from ctypes import (c_buffer, POINTER, byref, create_unicode_buffer,

Structure, WinDLL, _Pointer)

from ctypes.wintypes import DWORD, HANDLE

class VS_FIXEDFILEINFO(Structure):

_fields_ = [

("dwSignature", DWORD),

("dwStrucVersion", DWORD),

("dwFileVersionMS", DWORD),

("dwFileVersionLS", DWORD),

("dwProductVersionMS", DWORD),

("dwProductVersionLS", DWORD),

("dwFileFlagsMask", DWORD),

("dwFileFlags", DWORD),

("dwFileOS", DWORD),

("dwFileType", DWORD),

("dwFileSubtype", DWORD),

("dwFileDateMS", DWORD),

("dwFileDateLS", DWORD),

]

class PVS_FIXEDFILEINFO(_Pointer):

_type_ = VS_FIXEDFILEINFO

kernel32 = WinDLL('kernel32')

version = WinDLL('version')

# We will immediately double the length up to MAX_PATH, but the

# path may be longer, so we retry until the returned string is

# shorter than our buffer.

name_len = actual_len = 130

while actual_len == name_len:

name_len *= 2

name = create_unicode_buffer(name_len)

actual_len = kernel32.GetModuleFileNameW(HANDLE(kernel32._handle),

name, len(name))

if not actual_len:

return maj, min, build

size = version.GetFileVersionInfoSizeW(name, None)

if not size:

return maj, min, build

ver_block = c_buffer(size)

if (not version.GetFileVersionInfoW(name, None, size, ver_block) or

not ver_block):

return maj, min, build

pvi = PVS_FIXEDFILEINFO()

if not version.VerQueryValueW(ver_block, "", byref(pvi), byref(DWORD())):

return maj, min, build

maj = pvi.contents.dwProductVersionMS >> 16

min = pvi.contents.dwProductVersionMS & 0xFFFF

build = pvi.contents.dwProductVersionLS >> 16

try:

from sys import getwindowsversion

except ImportError:

return release, version, csd, ptype

try:

from winreg import OpenKeyEx, QueryValueEx, CloseKey, HKEY_LOCAL_MACHINE

except ImportError:

from _winreg import OpenKeyEx, QueryValueEx, CloseKey, HKEY_LOCAL_MACHINE

winver = getwindowsversion()

maj, min, build = _get_real_winver(*winver[:3])

version = '{0}.{1}.{2}'.format(maj, min, build)

release = (_WIN32_CLIENT_RELEASES.get((maj, min)) or

_WIN32_CLIENT_RELEASES.get((maj, None)) or

release)

# getwindowsversion() reflect the compatibility mode Python is

# running under, and so the service pack value is only going to be

# valid if the versions match.

if winver[:2] == (maj, min):

try:

csd = 'SP{}'.format(winver.service_pack_major)

except AttributeError:

if csd[:13] == 'Service Pack ':

csd = 'SP' + csd[13:]

# VER_NT_SERVER = 3

if getattr(winver, 'product_type', None) == 3:

release = (_WIN32_SERVER_RELEASES.get((maj, min)) or

_WIN32_SERVER_RELEASES.get((maj, None)) or

release)

key = None

try:

key = OpenKeyEx(HKEY_LOCAL_MACHINE,

r'SOFTWARE\Microsoft\Windows NT\CurrentVersion')

ptype = QueryValueEx(key, 'CurrentType')[0]

except:

pass

finally:

if key:

CloseKey(key)

from gestalt import gestalt

import MacOS

l = []

append = l.append

for selector in selectors:

try:

append(gestalt(selector))

except (RuntimeError, MacOS.Error):

append(default)

"""

# Check whether the version info module is available

try:

import gestalt

import MacOS

except ImportError:

return None

# Get the infos

sysv,sysa = _mac_ver_lookup(('sysv','sysa'))

# Decode the infos

if sysv:

major = (sysv & 0xFF00) >> 8

minor = (sysv & 0x00F0) >> 4

patch = (sysv & 0x000F)

if (major, minor) >= (10, 4):

# the 'sysv' gestald cannot return patchlevels

# higher than 9. Apple introduced 3 new

# gestalt codes in 10.4 to deal with this

# issue (needed because patch levels can

# run higher than 9, such as 10.4.11)

major,minor,patch = _mac_ver_lookup(('sys1','sys2','sys3'))

release = '%i.%i.%i' %(major, minor, patch)

else:

release = '%s.%i.%i' % (_bcd2str(major),minor,patch)

if sysa:

machine = {0x1: '68k',

0x2: 'PowerPC',

0xa: 'i386'}.get(sysa,'')

versioninfo=('', '', '')

fn = '/System/Library/CoreServices/SystemVersion.plist'

if not os.path.exists(fn):

return None

try:

import plistlib

except ImportError:

return None

pl = plistlib.readPlist(fn)

release = pl['ProductVersion']

versioninfo=('', '', '')

machine = os.uname()[4]

if machine in ('ppc', 'Power Macintosh'):

# for compatibility with the gestalt based code

machine = 'PowerPC'

""" Get MacOS version information and return it as tuple (release,

# First try reading the information from an XML file which should

# always be present

info = _mac_ver_xml()

if info is not None:

return info

# If that doesn't work for some reason fall back to reading the

# information using gestalt calls.

info = _mac_ver_gestalt()

if info is not None:

return info

# If that also doesn't work return the default values

from java.lang import System

try:

value = System.getProperty(name)

if value is None:

return default

return value

except AttributeError:

""" Version interface for Jython.

# Import the needed APIs

try:

import java.lang

except ImportError:

return release,vendor,vminfo,osinfo

vendor = _java_getprop('java.vendor', vendor)

release = _java_getprop('java.version', release)

vm_name, vm_release, vm_vendor = vminfo

vm_name = _java_getprop('java.vm.name', vm_name)

vm_vendor = _java_getprop('java.vm.vendor', vm_vendor)

vm_release = _java_getprop('java.vm.version', vm_release)

vminfo = vm_name, vm_release, vm_vendor

os_name, os_version, os_arch = osinfo

os_arch = _java_getprop('java.os.arch', os_arch)

os_name = _java_getprop('java.os.name', os_name)

os_version = _java_getprop('java.os.version', os_version)

osinfo = os_name, os_version, os_arch

""" Returns (system,release,version) aliased to common

if system == 'Rhapsody':

# Apple's BSD derivative

# XXX How can we determine the marketing release number ?

return 'MacOS X Server',system+release,version

elif system == 'SunOS':

# Sun's OS

if release < '5':

# These releases use the old name SunOS

return system,release,version

# Modify release (marketing release = SunOS release - 3)

l = string.split(release,'.')

if l:

try:

major = int(l[0])

except ValueError:

pass

else:

major = major - 3

l[0] = str(major)

release = string.join(l,'.')

if release < '6':

system = 'Solaris'

else:

# XXX Whatever the new SunOS marketing name is...

system = 'Solaris'

elif system == 'IRIX64':

# IRIX reports IRIX64 on platforms with 64-bit support; yet it

# is really a version and not a different platform, since 32-bit

# apps are also supported..

system = 'IRIX'

if version:

version = version + ' (64bit)'

else:

version = '64bit'

elif system in ('win32','win16'):

# In case one of the other tricks

system = 'Windows'

""" Helper to format the platform string in a filename

# Format the platform string

platform = string.join(

map(string.strip,

filter(len, args)),

'-')

# Cleanup some possible filename obstacles...

replace = string.replace

platform = replace(platform,' ','_')

platform = replace(platform,'/','-')

platform = replace(platform,'\\','-')

platform = replace(platform,':','-')

platform = replace(platform,';','-')

platform = replace(platform,'"','-')

platform = replace(platform,'(','-')

platform = replace(platform,')','-')

# No need to report 'unknown' information...

platform = replace(platform,'unknown','')

# Fold '--'s and remove trailing '-'

while 1:

cleaned = replace(platform,'--','-')

if cleaned == platform:

break

platform = cleaned

while platform[-1] == '-':

platform = platform[:-1]

""" Helper to determine the node name of this machine.

try:

import socket

except ImportError:

# No sockets...

return default

try:

return socket.gethostname()

except socket.error:

# Still not working...

isabs=os.path.isabs,join=os.path.join,getcwd=os.getcwd,

normpath=os.path.normpath):

if not isabs(path):

path = join(getcwd(), path)

""" In case filepath is a symlink, follow it until a

filepath = _abspath(filepath)

while os.path.islink(filepath):

filepath = os.path.normpath(

os.path.join(os.path.dirname(filepath),os.readlink(filepath)))

""" Interface to the system's uname command.

if sys.platform in ('dos','win32','win16','os2'):

# XXX Others too ?

return default

try:

f = os.popen('uname %s 2> %s' % (option, DEV_NULL))

except (AttributeError,os.error):

return default

output = string.strip(f.read())

rc = f.close()