# 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,

component_re = re.compile(r'([0-9]+|[._+-])')

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))

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

if not executable:

if sys.platform == "emscripten":

# Emscripten's os.confstr reports that it is glibc, so special case

# it.

ver = ".".join(str(x) for x in sys._emscripten_info.emscripten_version)

return ("emscripten", ver)

try:

ver = os.confstr('CS_GNU_LIBC_VERSION')

# parse 'glibc 2.28' as ('glibc', '2.28')

parts = ver.split(maxsplit=1)

if len(parts) == 2:

return tuple(parts)

except (AttributeError, ValueError, OSError):

# os.confstr() or CS_GNU_LIBC_VERSION value not available

pass

executable = sys.executable

if not executable:

# sys.executable is not set.

return lib, version

libc_search = re.compile(br"""

""",

re.ASCII | re.VERBOSE)

V = _comparable_version

# We use os.path.realpath()

# here to work around problems with Cygwin not being

# able to open symlinks for reading

executable = os.path.realpath(executable)

ver = None

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

binary = f.read(chunksize)

pos = 0

while pos < len(binary):

if b'libc' in binary or b'GLIBC' in binary or b'musl' 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

decoded_groups = [s.decode('latin1') if s is not None else s

for s in m.groups()]

(libcinit, glibc, glibcversion, so, threads, soversion,

musl, muslversion, musl_so, musl_sover) = decoded_groups

if libcinit and not lib:

lib = 'libc'

elif glibc:

if lib != 'glibc':

lib = 'glibc'

ver = glibcversion

elif V(glibcversion) > V(ver):

ver = glibcversion

elif so:

if lib not in ('glibc', 'musl'):

lib = 'libc'

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

ver = soversion

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

ver = ver + threads

elif musl:

lib = 'musl'

if not ver or V(muslversion) > V(ver):

ver = muslversion

elif musl_so:

lib = 'musl'

if musl_sover and (not ver or V(musl_sover) > V(ver)):

ver = musl_sover

pos = m.end()

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

l = version.split('.')

if build:

l.append(build)

try:

strings = list(map(str, map(int, l)))

except ValueError:

strings = l

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

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

""" 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

import subprocess

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

try:

info = subprocess.check_output(cmd,

stdin=subprocess.DEVNULL,

stderr=subprocess.DEVNULL,

text=True,

encoding="locale",

shell=True)

except (OSError, subprocess.CalledProcessError):

continue

else:

break

else:

return system, release, version

ver_output = re.compile(r'(?:([\w ]+) ([\w.]+) '

r'.*'

r'\[.* ([\d.]+)\])')

# Parse the output

info = info.strip()

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)

global _wmi

if not _wmi:

raise OSError("not supported")

table = {

"OS": "Win32_OperatingSystem",

"CPU": "Win32_Processor",

}[table]

try:

data = _wmi.exec_query("SELECT {} FROM {}".format(

",".join(keys),

table,

)).split("\0")

except OSError:

_wmi = None

raise OSError("not supported")

split_data = (i.partition("=") for i in data)

dict_data = {i[0]: i[2] for i in split_data}

((10, 1, 0), "post11"),

((10, 0, 22000), "11"),

((6, 4, 0), "10"),

((6, 3, 0), "8.1"),

((6, 2, 0), "8"),

((6, 1, 0), "7"),

((6, 0, 0), "Vista"),

((5, 2, 3790), "XP64"),

((5, 2, 0), "XPMedia"),

((5, 1, 0), "XP"),

((5, 0, 0), "2000"),

((10, 1, 0), "post2025Server"),

((10, 0, 26100), "2025Server"),

((10, 0, 20348), "2022Server"),

((10, 0, 17763), "2019Server"),

((6, 4, 0), "2016Server"),

((6, 3, 0), "2012ServerR2"),

((6, 2, 0), "2012Server"),

((6, 1, 0), "2008ServerR2"),

((6, 0, 0), "2008Server"),

((5, 2, 0), "2003Server"),

((5, 0, 0), "2000Server"),

try:

import winreg

except ImportError:

pass

else:

try:

cvkey = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion'

with winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE, cvkey) as key:

return winreg.QueryValueEx(key, 'EditionId')[0]

except OSError:

pass

# Try using WMI first, as this is the canonical source of data

try:

(version, product_type, ptype, spmajor, spminor) = _wmi_query(

'OS',

'Version',

'ProductType',

'BuildType',

'ServicePackMajorVersion',

'ServicePackMinorVersion',

)

is_client = (int(product_type) == 1)

if spminor and spminor != '0':

csd = f'SP{spmajor}.{spminor}'

else:

csd = f'SP{spmajor}'

return version, csd, ptype, is_client

except OSError:

pass

# Fall back to a combination of sys.getwindowsversion and "ver"

try:

from sys import getwindowsversion

except ImportError:

return version, csd, ptype, True

winver = getwindowsversion()

is_client = (getattr(winver, 'product_type', 1) == 1)

if winver.device_family == "Desktop":

try:

version = _syscmd_ver()[2]

major, minor, build = map(int, version.split('.'))

except ValueError:

major, minor, build = winver.platform_version or winver[:3]

version = '{0}.{1}.{2}'.format(major, minor, build)

else:

major, minor, build = winver[:3]

version = '{0}.{1}.{2}'.format(major, minor, build)

# 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] == (major, minor):

try:

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

except AttributeError:

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

csd = 'SP' + csd[13:]

try:

import winreg

except ImportError:

pass

else:

try:

cvkey = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion'

with winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE, cvkey) as key:

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

except OSError:

pass

is_client = False

version, csd, ptype, is_client = _win32_ver(version, csd, ptype)

if version:

intversion = tuple(map(int, version.split('.')))

releases = _WIN32_CLIENT_RELEASES if is_client else _WIN32_SERVER_RELEASES

release = next((r for v, r in releases if v <= intversion), release)

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

if not os.path.exists(fn):

return None

try:

import plistlib

except ImportError:

return None

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

pl = plistlib.load(f)

release = pl['ProductVersion']

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

machine = os.uname().machine

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

# Canonical name

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 also doesn't work return the default values

"""Get iOS/tvOS/watchOS/visionOS version information, and return it as a

if sys.platform in {"ios", "tvos", "visionos", "watchos"}:

import _ios_support

result = _ios_support.get_platform_ios()

if result is not None:

return IOSVersionInfo(*result)

is_emulator=False):

if sys.platform == "android":

try:

from ctypes import CDLL, c_int, c_char_p, create_string_buffer

from ctypes.util import wrap_dll_function

except ImportError:

pass

else:

# An NDK developer confirmed that this is an officially-supported

# API (https://stackoverflow.com/a/28416743). Use `getattr` to avoid

# private name mangling.

libc = CDLL("libc.so")

@wrap_dll_function(libc)

def __system_property_get(name: c_char_p, value: c_char_p) -> c_int:

pass

def getprop(name, default):

# https://android.googlesource.com/platform/bionic/+/refs/tags/android-5.0.0_r1/libc/include/sys/system_properties.h#39

PROP_VALUE_MAX = 92

buffer = create_string_buffer(PROP_VALUE_MAX)

length = __system_property_get(name.encode("UTF-8"), buffer)

if length == 0:

# This API doesn’t distinguish between an empty property and

# a missing one.

return default

else:

return buffer.value.decode("UTF-8", "backslashreplace")

release = getprop("ro.build.version.release", release)

api_level = int(getprop("ro.build.version.sdk", api_level))

manufacturer = getprop("ro.product.manufacturer", manufacturer)

model = getprop("ro.product.model", model)

device = getprop("ro.product.device", device)

is_emulator = getprop("ro.kernel.qemu", "0") == "1"

return AndroidVer(

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

if 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 = release.split('.')

if l:

try:

major = int(l[0])

except ValueError:

pass

else:

major = major - 3

l[0] = str(major)

release = '.'.join(l)

if release < '6':

system = 'Solaris'

else:

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

system = 'Solaris'

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

# In case one of the other tricks

system = 'Windows'

# bpo-35516: Don't replace Darwin with macOS since input release and

# version arguments can be different than the currently running version.

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

# Format the platform string

platform = '-'.join(x.strip() for x in filter(len, args))

# Cleanup some possible filename obstacles...

platform = platform.translate(_SIMPLE_SUBSTITUTIONS)

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

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

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

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

try:

import socket

except ImportError:

# No sockets...

return default

try:

return socket.gethostname()

except OSError:

# Still not working...

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

filepath = os.path.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 file command.

if sys.platform in {'dos', 'win32', 'win16', 'ios', 'tvos', 'visionos', 'watchos'}:

# XXX Others too ?

return default

try:

import subprocess

except ImportError:

return default

target = _follow_symlinks(target)

# "file" output is locale dependent: force the usage of the C locale

# to get deterministic behavior.

env = dict(os.environ, LC_ALL='C')

try:

# -b: do not prepend filenames to output lines (brief mode)

output = subprocess.check_output(['file', '-b', target],

stderr=subprocess.DEVNULL,

env=env)

except (OSError, subprocess.CalledProcessError):

return default

if not output:

return default

# With the C locale, the output should be mostly ASCII-compatible.

# Decode from Latin-1 to prevent Unicode decode error.

'win32': ('', 'WindowsPE'),

'win16': ('', 'Windows'),

'dos': ('', 'MSDOS'),

""" Queries the given executable (defaults to the Python interpreter

# Use the sizeof(pointer) as default number of bits if nothing

# else is given as default.

if not bits:

import struct

size = struct.calcsize('P')

bits = str(size * 8) + 'bit'

# Get data from the 'file' system command

if executable:

fileout = _syscmd_file(executable, '')

else:

fileout = ''

if not fileout and \

executable == sys.executable:

# "file" command did not return anything; we'll try to provide

# some sensible defaults then...

if sys.platform in _default_architecture:

b, l = _default_architecture[sys.platform]

if b:

bits = b

if l:

linkage = l

return bits, linkage

if 'executable' not in fileout and 'shared object' not in fileout:

# Format not supported

return bits, linkage

# Bits

if '32-bit' in fileout:

bits = '32bit'

elif '64-bit' in fileout:

bits = '64bit'

# Linkage

if 'ELF' in fileout:

linkage = 'ELF'

elif 'Mach-O' in fileout:

linkage = "Mach-O"

elif 'PE' in fileout:

# E.g. Windows uses this format

if 'Windows' in fileout:

linkage = 'WindowsPE'

else:

linkage = 'PE'

elif 'COFF' in fileout:

linkage = 'COFF'

elif 'MS-DOS' in fileout:

linkage = 'MSDOS'

else:

# XXX the A.OUT format also falls under this class...

pass

# Try to use the PROCESSOR_* environment variables

# available on Win XP and later; see

# http://support.microsoft.com/kb/888731 and

# http://www.geocities.com/rick_lively/MANUALS/ENV/MSWIN/PROCESSI.HTM

# WOW64 processes mask the native architecture

try:

[arch, *_] = _wmi_query('CPU', 'Architecture')

except OSError:

pass

else:

try:

arch = ['x86', 'MIPS', 'Alpha', 'PowerPC', None,

'ARM', 'ia64', None, None,

'AMD64', None, None, 'ARM64',

][int(arch)]

except (ValueError, IndexError):

pass

else:

if arch:

return arch

return (

os.environ.get('PROCESSOR_ARCHITEW6432', '') or

os.environ.get('PROCESSOR_ARCHITECTURE', '')

@classmethod

def get(cls):

func = getattr(cls, f'get_{sys.platform}', cls.from_subprocess)

return func() or ''

def get_win32():

try:

manufacturer, caption = _wmi_query('CPU', 'Manufacturer', 'Caption')

except OSError:

return os.environ.get('PROCESSOR_IDENTIFIER', _get_machine_win32())

else:

return f'{caption}, {manufacturer}'

def get_OpenVMS():

try:

import vms_lib

except ImportError:

pass

else:

csid, cpu_number = vms_lib.getsyi('SYI$_CPU', 0)

return 'Alpha' if cpu_number >= 128 else 'VAX'

# On the iOS/tvOS/visionOS/watchOS simulator, os.uname returns the

# architecture as uname.machine. On device it returns the model name for

# some reason; but there's only one CPU architecture for devices, so we know

# the right answer.

def get_ios():

if sys.implementation._multiarch.endswith("simulator"):

return os.uname().machine

return 'arm64'

def get_tvos():

if sys.implementation._multiarch.endswith("simulator"):

return os.uname().machine

return 'arm64'

def get_visionos():

if sys.implementation._multiarch.endswith("simulator"):

return os.uname().machine

return 'arm64'

def get_watchos():

if sys.implementation._multiarch.endswith("simulator"):

return os.uname().machine

return 'arm64_32'

def from_subprocess():

"""

try:

import subprocess

except ImportError:

return None

try:

return subprocess.check_output(

['uname', '-p'],

stderr=subprocess.DEVNULL,

text=True,

encoding="utf8",

).strip()

except (OSError, subprocess.CalledProcessError):

collections.namedtuple(

"uname_result_base",

"system node release version machine")

):

"""

_fields = ('system', 'node', 'release', 'version', 'machine', 'processor')

@functools.cached_property

def processor(self):

return _unknown_as_blank(_Processor.get())

def __iter__(self):

return itertools.chain(

super().__iter__(),

(self.processor,)

)

@classmethod

def _make(cls, iterable):

# override factory to affect length check

num_fields = len(cls._fields) - 1

result = cls.__new__(cls, *iterable)

if len(result) != num_fields + 1:

msg = f'Expected {num_fields} arguments, got {len(result)}'

raise TypeError(msg)

return result

def __getitem__(self, key):

return tuple(self)[key]

def __len__(self):

return len(tuple(iter(self)))

def __reduce__(self):

""" Fairly portable uname interface. Returns a tuple

global _uname_cache

if _uname_cache is not None:

return _uname_cache

# Get some infos from the builtin os.uname API...

try:

system, node, release, version, machine = infos = os.uname()

except AttributeError:

system = sys.platform

node = _node()

release = version = machine = ''

infos = ()

if not any(infos):

# uname is not available

# Try win32_ver() on win32 platforms

if system == 'win32':

release, version, csd, ptype = win32_ver()

machine = machine or _get_machine_win32()

# Try the 'ver' system command available on some

# platforms

if not (release and version):

system, release, version = _syscmd_ver(system)

# Normalize system to what win32_ver() normally returns

# (_syscmd_ver() tends to return the vendor name as well)

if system == 'Microsoft Windows':

system = 'Windows'

elif system == 'Microsoft' and release == 'Windows':

# Under Windows Vista and Windows Server 2008,

# Microsoft changed the output of the ver command. The

# release is no longer printed. This causes the

# system and release to be misidentified.

system = 'Windows'

if '6.0' == version[:3]:

release = 'Vista'

else:

release = ''