def simple_test(self):
v1 = Version("1.2.3")
self.assertTrue(v1 == "1.2.3")
self.assertTrue(v1 > "1.1")
self.assertTrue(v1 > None)
self.assertTrue(v1 < "1.11")
self.assertTrue(v1 > "1.2")
self.assertTrue(v1 > "1.2.2.2")
self.assertTrue(v1 < "1.2.3.2")
self.assertEqual(v1.major(), "1.Y.Z") # 1.X.Y
self.assertEqual(v1.minor(), "1.2.Z") # 1.2.Y
self.assertEqual(v1.patch(), "1.2.3")
self.assertEqual(v1.pre(), "1.2.3")
self.assertEqual(v1.build, "")
self.assertTrue(v1.compatible("1.X"))
self.assertTrue(v1.compatible("1.2.Y"))
self.assertFalse(v1.compatible("0.X"))
v2 = v1.minor()
self.assertTrue(v2.compatible("1.X"))
self.assertTrue(v2.compatible("1.2.3.4"))
self.assertFalse(v2.compatible("1.3.3.4"))
v1 = Version("1.2.rc1")
self.assertTrue(v1 < "1.2.0")
self.assertFalse(v1 < "1.1.9")
self.assertTrue(Version("1.2.1-dev") < Version("1.2.1"))
self.assertTrue(Version("1.2.1-dev") < Version("1.2.2"))
self.assertTrue(Version("1.2.1-dev") < Version("1.3"))
self.assertTrue(Version("1.2.1-dev") < Version("1.3-alpha"))
self.assertTrue(Version("1.2.1-dev") > Version("1.2.0"))
self.assertTrue(Version("1.2.1-dev") > Version("1.2"))
self.assertTrue(Version("1.2.1-dev") > Version("1.2.alpha"))
self.assertTrue(Version("1.2.1-dev") > Version("1.2-alpha"))
def simple_test(self):
v1 = Version("1.2.3")
self.assertTrue(v1 == "1.2.3")
self.assertTrue(v1 > "1.1")
self.assertTrue(v1 > None)
self.assertTrue(v1 < "1.11")
self.assertTrue(v1 > "1.2")
self.assertTrue(v1 > "1.2.2.2")
self.assertTrue(v1 < "1.2.3.2")
self.assertEqual(v1.major(), "1.Y.Z") # 1.X.Y
self.assertEqual(v1.minor(), "1.2.Z") # 1.2.Y
self.assertEqual(v1.patch(), "1.2.3")
self.assertEqual(v1.pre(), "1.2.3")
self.assertEqual(v1.build, "")
self.assertTrue(v1.compatible("1.X"))
self.assertTrue(v1.compatible("1.2.Y"))
self.assertFalse(v1.compatible("0.X"))
v2 = v1.minor()
self.assertTrue(v2.compatible("1.X"))
self.assertTrue(v2.compatible("1.2.3.4"))
self.assertFalse(v2.compatible("1.3.3.4"))
v1 = Version("1.2.rc1")
self.assertTrue(v1 < "1.2.0")
self.assertFalse(v1 < "1.1.9")
self.assertTrue(Version("1.2.1-dev") < Version("1.2.1"))
self.assertTrue(Version("1.2.1-dev") < Version("1.2.2"))
self.assertTrue(Version("1.2.1-dev") < Version("1.3"))
self.assertTrue(Version("1.2.1-dev") < Version("1.3-alpha"))
self.assertTrue(Version("1.2.1-dev") > Version("1.2.0"))
self.assertTrue(Version("1.2.1-dev") > Version("1.2"))
self.assertTrue(Version("1.2.1-dev") > Version("1.2.alpha"))
self.assertTrue(Version("1.2.1-dev") > Version("1.2-alpha"))
def simple_test(self):
v1 = Version("1.2.3")
self.assertTrue(v1 == "1.2.3")
self.assertTrue(v1 > "1.1")
self.assertTrue(v1 > None)
self.assertTrue(v1 < "1.11")
self.assertEqual(v1.major(), "1.Y.Z") # 1.X.Y
self.assertEqual(v1.minor(), "1.2.Z") # 1.2.Y
self.assertTrue(v1.compatible("1.X"))
self.assertTrue(v1.compatible("1.2.Y"))
self.assertFalse(v1.compatible("0.X"))
v2 = v1.minor()
self.assertTrue(v2.compatible("1.X"))
self.assertTrue(v2.compatible("1.2.3.4"))
self.assertFalse(v2.compatible("1.3.3.4"))
def test_text(self):
v1 = Version("master+build2")
self.assertEqual(v1.major(), "master")
self.assertEqual(v1.minor(), "master")
self.assertEqual(v1.patch(), "master")
self.assertEqual(v1.pre(), "master")
self.assertEqual(v1.build, "build2")
self.assertEqual(v1.stable(), "master")
def text_test(self):
v1 = Version("master+build2")
self.assertEqual(v1.major(), "master")
self.assertEqual(v1.minor(), "master")
self.assertEqual(v1.patch(), "master")
self.assertEqual(v1.pre(), "master")
self.assertEqual(v1.build, "build2")
self.assertEqual(v1.stable(), "master")
def simple_test(self):
v1 = Version("1.2.3")
self.assertTrue(v1 == "1.2.3")
self.assertTrue(v1 > "1.1")
self.assertTrue(v1 > None)
self.assertTrue(v1 < "1.11")
self.assertTrue(v1 > "1.2")
self.assertTrue(v1 > "1.2.2.2")
self.assertTrue(v1 < "1.2.3.2")
self.assertEqual(v1.major(), "1.Y.Z") # 1.X.Y
self.assertEqual(v1.minor(), "1.2.Z") # 1.2.Y
self.assertTrue(v1.compatible("1.X"))
self.assertTrue(v1.compatible("1.2.Y"))
self.assertFalse(v1.compatible("0.X"))
v2 = v1.minor()
self.assertTrue(v2.compatible("1.X"))
self.assertTrue(v2.compatible("1.2.3.4"))
self.assertFalse(v2.compatible("1.3.3.4"))
v1 = Version("1.2.rc1")
self.assertTrue(v1 < "1.2.0")
self.assertFalse(v1 < "1.1.9")
def test_patch(self):
v1 = Version("1.2.3-alpha1+build2")
self.assertEqual(v1.major(), "1.Y.Z")
self.assertEqual(v1.minor(), "1.2.Z")
self.assertEqual(v1.patch(), "1.2.3")
self.assertEqual(v1.pre(), "1.2.3-alpha1")
self.assertEqual(v1.build, "build2")
self.assertEqual(v1.stable(), "1.Y.Z")
v1 = Version("1.2.3+build2")
self.assertEqual(v1.major(), "1.Y.Z")
self.assertEqual(v1.minor(), "1.2.Z")
self.assertEqual(v1.patch(), "1.2.3")
self.assertEqual(v1.pre(), "1.2.3")
self.assertEqual(v1.build, "build2")
self.assertEqual(v1.stable(), "1.Y.Z")
v1 = Version("0.2.3-alpha1+build2")
self.assertEqual(v1.major(), "0.Y.Z")
self.assertEqual(v1.minor(), "0.2.Z")
self.assertEqual(v1.patch(), "0.2.3")
self.assertEqual(v1.pre(), "0.2.3-alpha1")
self.assertEqual(v1.build, "build2")
self.assertEqual(v1.stable(), "0.2.3-alpha1+build2")
def patch_test(self):
v1 = Version("1.2.3-alpha1+build2")
self.assertEqual(v1.major(), "1.Y.Z")
self.assertEqual(v1.minor(), "1.2.Z")
self.assertEqual(v1.patch(), "1.2.3")
self.assertEqual(v1.pre(), "1.2.3-alpha1")
self.assertEqual(v1.build, "build2")
self.assertEqual(v1.stable(), "1.Y.Z")
v1 = Version("1.2.3+build2")
self.assertEqual(v1.major(), "1.Y.Z")
self.assertEqual(v1.minor(), "1.2.Z")
self.assertEqual(v1.patch(), "1.2.3")
self.assertEqual(v1.pre(), "1.2.3")
self.assertEqual(v1.build, "build2")
self.assertEqual(v1.stable(), "1.Y.Z")
v1 = Version("0.2.3-alpha1+build2")
self.assertEqual(v1.major(), "0.Y.Z")
self.assertEqual(v1.minor(), "0.2.Z")
self.assertEqual(v1.patch(), "0.2.3")
self.assertEqual(v1.pre(), "0.2.3-alpha1")
self.assertEqual(v1.build, "build2")
self.assertEqual(v1.stable(), "0.2.3-alpha1+build2")
def get_best_installer(arch, threads, exception, version):
if arch == "x86":
arch = "i686"
if exception == "dwarf2":
exception = "dwarf"
tools.download(repository_file, "repository.txt", overwrite=True, retry=10)
installers = []
with open("repository.txt") as f:
for line in f.readlines():
installers.append(Installer(line))
version = Version(version)
def params_match(i):
return arch == i.arch and threads == i.threads and exception == i.exception
def better_choice(i):
return not best_match or i.version > best_match.version or (
i.version == best_match.version
and i.revision > best_match.revision)
best_match = None
for i in installers:
if len(version.as_list) == 1:
if i.version.major() == version.major() and params_match(
i) and better_choice(i):
best_match = i
elif len(version.as_list) == 2:
if i.version.major() == version.major() and i.version.minor(
) == version.minor() and params_match(i) and better_choice(i):
best_match = i
elif len(version.as_list) == 3:
if i.version == version and params_match(i) and better_choice(i):
best_match = i
if not best_match:
raise Exception(
"There is no suitable MinGW release for the requested features %s %s %s %s"
% (arch, threads, exception, version))
else:
return best_match
def get_best_installer(arch, threads, exception, version):
if arch == "x86":
arch = "i686"
if exception == "dwarf2":
exception = "dwarf"
tools.download(repository_file, "repository.txt", overwrite=True, retry=10)
installers = []
with open("repository.txt") as f:
for line in f.readlines():
installers.append(Installer(line))
version = Version(version)
def params_match(i):
return arch == i.arch and threads == i.threads and exception == i.exception
def better_choice(i):
return not best_match or i.version > best_match.version or (i.version == best_match.version and i.revision > best_match.revision)
best_match = None
for i in installers:
if len(version.as_list) == 1:
if i.version.major() == version.major() and params_match(i) and better_choice(i):
best_match = i
elif len(version.as_list) == 2:
if i.version.major() == version.major() and i.version.minor() == version.minor() and params_match(i) and better_choice(i):
best_match = i
elif len(version.as_list) == 3:
if i.version == version and params_match(i) and better_choice(i):
best_match = i
if not best_match:
raise Exception("There is no suitable MinGW release for the requested features %s %s %s %s" % (arch, threads, exception, version))
else:
return best_match
class OSInfo(object):
""" Usage:
(os_info.is_linux) # True/False
(os_info.is_windows) # True/False
(os_info.is_macos) # True/False
(os_info.is_freebsd) # True/False
(os_info.is_solaris) # True/False
(os_info.linux_distro) # debian, ubuntu, fedora, centos...
(os_info.os_version) # 5.1
(os_info.os_version_name) # Windows 7, El Capitan
if os_info.os_version > "10.1":
pass
if os_info.os_version == "10.1.0":
pass
"""
def __init__(self):
system = platform.system()
self.os_version = None
self.os_version_name = None
self.is_linux = system == "Linux"
self.linux_distro = None
self.is_msys = system.startswith("MING") or system.startswith(
"MSYS_NT")
self.is_cygwin = system.startswith("CYGWIN_NT")
self.is_windows = system == "Windows" or self.is_msys or self.is_cygwin
self.is_macos = system == "Darwin"
self.is_freebsd = system == "FreeBSD"
self.is_solaris = system == "SunOS"
self.is_aix = system == "AIX"
self.is_posix = os.pathsep == ':'
if self.is_linux:
self._get_linux_distro_info()
elif self.is_windows:
self.os_version = self.get_win_os_version()
self.os_version_name = self.get_win_version_name(self.os_version)
elif self.is_macos:
self.os_version = Version(platform.mac_ver()[0])
self.os_version_name = self.get_osx_version_name(self.os_version)
elif self.is_freebsd:
self.os_version = self.get_freebsd_version()
self.os_version_name = "FreeBSD %s" % self.os_version
elif self.is_solaris:
self.os_version = Version(platform.release())
self.os_version_name = self.get_solaris_version_name(
self.os_version)
elif self.is_aix:
self.os_version = self.get_aix_version()
self.os_version_name = "AIX %s" % self.os_version.minor(fill=False)
def _get_linux_distro_info(self):
import distro
self.linux_distro = distro.id()
self.os_version = Version(distro.version())
version_name = distro.codename()
self.os_version_name = version_name if version_name != "n/a" else ""
if not self.os_version_name and self.linux_distro == "debian":
self.os_version_name = self.get_debian_version_name(
self.os_version)
@property
def with_apt(self):
if not self.is_linux:
return False
apt_location = which('apt-get')
if apt_location:
# Check if we actually have the official apt package.
try:
output = check_output_runner([apt_location, 'moo'])
except CalledProcessErrorWithStderr:
return False
else:
# Yes, we have mooed today. :-) MOOOOOOOO.
return True
else:
return False
@property
def with_yum(self):
return self.is_linux and self.linux_distro in (
"pidora", "fedora", "scientific", "centos", "redhat", "rhel",
"xenserver", "amazon", "oracle")
@property
def with_dnf(self):
return self.is_linux and self.linux_distro == "fedora" and which('dnf')
@property
def with_pacman(self):
if self.is_linux:
return self.linux_distro in ["arch", "manjaro"]
elif self.is_windows and which('uname.exe'):
uname = check_output_runner(['uname.exe', '-s'])
return uname.startswith('MSYS_NT') and which('pacman.exe')
return False
@property
def with_zypper(self):
if not self.is_linux:
return False
if "opensuse" in self.linux_distro or "sles" in self.linux_distro:
return True
return False
@staticmethod
def get_win_os_version():
"""
Get's the OS major and minor versions. Returns a tuple of
(OS_MAJOR, OS_MINOR).
"""
import ctypes
class _OSVERSIONINFOEXW(ctypes.Structure):
_fields_ = [('dwOSVersionInfoSize', ctypes.c_ulong),
('dwMajorVersion', ctypes.c_ulong),
('dwMinorVersion', ctypes.c_ulong),
('dwBuildNumber', ctypes.c_ulong),
('dwPlatformId', ctypes.c_ulong),
('szCSDVersion', ctypes.c_wchar * 128),
('wServicePackMajor', ctypes.c_ushort),
('wServicePackMinor', ctypes.c_ushort),
('wSuiteMask', ctypes.c_ushort),
('wProductType', ctypes.c_byte),
('wReserved', ctypes.c_byte)]
os_version = _OSVERSIONINFOEXW()
os_version.dwOSVersionInfoSize = ctypes.sizeof(os_version)
if not hasattr(ctypes, "windll"):
return None
retcode = ctypes.windll.Ntdll.RtlGetVersion(ctypes.byref(os_version))
if retcode != 0:
return None
return Version("%d.%d" %
(os_version.dwMajorVersion, os_version.dwMinorVersion))
@staticmethod
def get_debian_version_name(version):
if not version:
return None
elif version.major() == "8.Y.Z":
return "jessie"
elif version.major() == "7.Y.Z":
return "wheezy"
elif version.major() == "6.Y.Z":
return "squeeze"
elif version.major() == "5.Y.Z":
return "lenny"
elif version.major() == "4.Y.Z":
return "etch"
elif version.minor() == "3.1.Z":
return "sarge"
elif version.minor() == "3.0.Z":
return "woody"
@staticmethod
def get_win_version_name(version):
if not version:
return None
elif version.major() == "5.Y.Z":
return "Windows XP"
elif version.minor() == "6.0.Z":
return "Windows Vista"
elif version.minor() == "6.1.Z":
return "Windows 7"
elif version.minor() == "6.2.Z":
return "Windows 8"
elif version.minor() == "6.3.Z":
return "Windows 8.1"
elif version.minor() == "10.0.Z":
return "Windows 10"
@staticmethod
def get_osx_version_name(version):
if not version:
return None
elif version.minor() == "10.13.Z":
return "High Sierra"
elif version.minor() == "10.12.Z":
return "Sierra"
elif version.minor() == "10.11.Z":
return "El Capitan"
elif version.minor() == "10.10.Z":
return "Yosemite"
elif version.minor() == "10.9.Z":
return "Mavericks"
elif version.minor() == "10.8.Z":
return "Mountain Lion"
elif version.minor() == "10.7.Z":
return "Lion"
elif version.minor() == "10.6.Z":
return "Snow Leopard"
elif version.minor() == "10.5.Z":
return "Leopard"
elif version.minor() == "10.4.Z":
return "Tiger"
elif version.minor() == "10.3.Z":
return "Panther"
elif version.minor() == "10.2.Z":
return "Jaguar"
elif version.minor() == "10.1.Z":
return "Puma"
elif version.minor() == "10.0.Z":
return "Cheetha"
@staticmethod
def get_aix_architecture():
processor = platform.processor()
if "powerpc" in processor:
kernel_bitness = OSInfo().get_aix_conf("KERNEL_BITMODE")
if kernel_bitness:
return "ppc64" if kernel_bitness == "64" else "ppc32"
elif "rs6000" in processor:
return "ppc32"
@staticmethod
def get_solaris_architecture():
# under intel solaris, platform.machine()=='i86pc' so we need to handle
# it early to suport 64-bit
processor = platform.processor()
kernel_bitness, elf = platform.architecture()
if "sparc" in processor:
return "sparcv9" if kernel_bitness == "64bit" else "sparc"
elif "i386" in processor:
return "x86_64" if kernel_bitness == "64bit" else "x86"
@staticmethod
def get_freebsd_version():
return platform.release().split("-")[0]
@staticmethod
def get_solaris_version_name(version):
if not version:
return None
elif version.minor() == "5.10":
return "Solaris 10"
elif version.minor() == "5.11":
return "Solaris 11"
@staticmethod
def get_aix_version():
try:
ret = check_output_runner("oslevel").strip()
return Version(ret)
except Exception:
return Version("%s.%s" % (platform.version(), platform.release()))
@staticmethod
def bash_path():
if os.getenv("CONAN_BASH_PATH"):
return os.getenv("CONAN_BASH_PATH")
return which("bash")
@staticmethod
def uname(options=None):
options = " %s" % options if options else ""
if not OSInfo().is_windows:
raise ConanException("Command only for Windows operating system")
custom_bash_path = OSInfo.bash_path()
if not custom_bash_path:
raise ConanException("bash is not in the path")
command = '"%s" -c "uname%s"' % (custom_bash_path, options)
try:
# the uname executable is many times located in the same folder as bash.exe
with environment_append(
{"PATH": [os.path.dirname(custom_bash_path)]}):
ret = check_output_runner(command).strip().lower()
return ret
except Exception:
return None
@staticmethod
def get_aix_conf(options=None):
options = " %s" % options if options else ""
if not OSInfo().is_aix:
raise ConanException("Command only for AIX operating system")
try:
ret = check_output_runner("getconf%s" % options).strip()
return ret
except Exception:
return None
@staticmethod
def detect_windows_subsystem():
from conans.client.tools.win import CYGWIN, MSYS2, MSYS, WSL
if OSInfo().is_linux:
try:
# https://github.com/Microsoft/WSL/issues/423#issuecomment-221627364
with open("/proc/sys/kernel/osrelease") as f:
return WSL if f.read().endswith("Microsoft") else None
except IOError:
return None
try:
output = OSInfo.uname()
except ConanException:
return None
if not output:
return None
if "cygwin" in output:
return CYGWIN
elif "msys" in output or "mingw" in output:
version = OSInfo.uname("-r").split('.')
if version and version[0].isdigit():
major = int(version[0])
if major == 1:
return MSYS
elif major >= 2:
return MSYS2
return None
elif "linux" in output:
return WSL
else:
return None
