def _load_machine_vars(self) -> None: """Load machine vars from data manager.""" self.machine_var_data_manager = self.create_data_manager( 'machine_vars') current_time = self.clock.get_time() for name, settings in (iter( self.machine_var_data_manager.get_data().items())): if not isinstance(settings, dict) or "value" not in settings: continue if ('expire' in settings and settings['expire'] and settings['expire'] < current_time): settings['value'] = 0 self.set_machine_var(name=name, value=settings['value']) self._load_initial_machine_vars() # Create basic system information machine variables self.set_machine_var(name="mpf_version", value=mpf_version) self.set_machine_var(name="mpf_extended_version", value=mpf_extended_version) self.set_machine_var(name="python_version", value=python_version()) self.set_machine_var(name="platform", value=platform(aliased=True)) platform_info = system_alias(system(), release(), version()) self.set_machine_var(name="platform_system", value=platform_info[0]) self.set_machine_var(name="platform_release", value=platform_info[1]) self.set_machine_var(name="platform_version", value=platform_info[2]) self.set_machine_var(name="platform_machine", value=machine())
def print_basic_debug_info(out=None): if out is None: out = sys.stdout out = functools.partial(prints, file=out) import platform from calibre.constants import (__appname__, get_version, isportable, isosx, isfrozen, is64bit) out(__appname__, get_version(), 'Portable' if isportable else '', 'embedded-python:', isfrozen, 'is64bit:', is64bit) out(platform.platform(), platform.system(), platform.architecture()) if iswindows and not is64bit: try: import win32process if win32process.IsWow64Process(): out('32bit process running on 64bit windows') except: pass out(platform.system_alias(platform.system(), platform.release(), platform.version())) out('Python', platform.python_version()) try: if iswindows: out('Windows:', platform.win32_ver()) elif isosx: out('OSX:', platform.mac_ver()) else: out('Linux:', platform.linux_distribution()) except: pass from calibre.customize.ui import has_external_plugins, initialized_plugins if has_external_plugins(): names = (p.name for p in initialized_plugins() if getattr(p, 'plugin_path', None) is not None) out('Successfully initialized third party plugins:', ' && '.join(names))
def report_failure(self, name, msg, show_traceback=True): "Report a test failure, with some useful context." orig_tb = _traceback.extract_tb(_sys.exc_info()[2]) tb = orig_tb # Move up the traceback until we get to the line in the test # function which caused the failure. while tb[-1][2] != "test_" + name: tb = tb[:-1] # Display the context in the text function. filepath, linenum, functionname, text = tb[-1] filename = _os.path.basename(filepath) self._out.ensure_space() self._out.write_colour("#red#FAILED##\n") if self._verbose > 0: if self._context is None: context = "" else: context = ", when %s" % self._context firstline = "%s:%d" % (filename, linenum) self._out.write("\n%s:%s%s\n" % (firstline, msg, context)) # Display sourcecode lines lines = open(filepath).readlines() startline = max(linenum - 3, 0) endline = min(linenum + 2, len(lines)) for num in range(startline, endline): if num + 1 == linenum: self._out.write("->") else: self._out.write(" ") self._out.write("%4d %s\n" % (num + 1, lines[num].rstrip())) # Display the traceback if show_traceback: self._out.write("Traceback (most recent call last):\n") for line in _traceback.format_list(orig_tb): self._out.write(line.rstrip() + "\n") self._out.write("\n") # Display some information about the xapian version and platform self._out.write("Xapian version: %s\n" % _xapian.version_string()) try: import platform platdesc = "%s %s (%s)" % platform.system_alias( platform.system(), platform.release(), platform.version() ) self._out.write("Platform: %s\n" % platdesc) except: pass self._out.write( '\nWhen reporting this problem, please quote all the preceding lines from\n"%s" onwards.\n\n' % firstline ) self._out.flush()
def print_basic_debug_info(out=None): if out is None: out = sys.stdout out = functools.partial(prints, file=out) import platform from calibre.constants import (__appname__, get_version, isportable, isosx, isfrozen, is64bit) out(__appname__, get_version(), 'Portable' if isportable else '', 'isfrozen:', isfrozen, 'is64bit:', is64bit) out(platform.platform(), platform.system(), platform.architecture()) if iswindows and not is64bit: try: import win32process if win32process.IsWow64Process(): out('32bit process running on 64bit windows') except: pass out( platform.system_alias(platform.system(), platform.release(), platform.version())) out('Python', platform.python_version()) try: if iswindows: out('Windows:', platform.win32_ver()) elif isosx: out('OSX:', platform.mac_ver()) else: out('Linux:', platform.linux_distribution()) except: pass
def get_env_info(): '''Gets general information about the computer.''' infodict = OrderedDict() infodict["Name"] = platform.node() infodict["System"] = platform.system() infodict["System alias"] = " ".join(platform.system_alias( platform.system(), platform.release(), platform.version())) infodict["Platform"] = platform.platform() if infodict["System"] == "Linux": # System-specific information infodict["Distribution"] = " ".join(platform.dist()) elif infodict["System"] == "Windows": infodict["OS"] = " ".join(platform.win32_ver()) elif infodict["System"] == "MacOS": verinfo = platform.mac_ver()[1] macver = " ".join(platform.mac_ver()) macver[1] = verinfo infodict["OS"] = " ".join(macver) infodict["Boot time"] = datetime.datetime.fromtimestamp( psutil.get_boot_time()).strftime("%c") infodict["Uptime"] = str(datetime.datetime.fromtimestamp( time.time() - psutil.get_boot_time()).strftime("%d:%H:%M:%S:%f")) for user in psutil.get_users(): infodict["User '" + user.name + "' terminal"] = user.terminal infodict["User '" + user.name + "' host"] = user.host infodict["User '" + user.name + "' started"] = str( datetime.datetime.fromtimestamp(user.started).strftime("%c")) return infodict
def get_os_info(): """ Get Operating System type/distribution and major version :returns: (os_name, os_version) :rtype: `tuple` of `str` """ info = platform.system_alias(platform.system(), platform.release(), platform.version()) os_type, os_ver, _ = info os_type = os_type.lower() if os_type.startswith('linux'): info = platform.linux_distribution() # On arch, platform.linux_distribution() is reportedly ('','',''), # so handle it defensively if info[0]: os_type = info[0] if info[1]: os_ver = info[1] elif os_type.startswith('darwin'): os_ver = subprocess.Popen(["sw_vers", "-productVersion"], stdout=subprocess.PIPE).communicate()[0] os_ver = os_ver.partition(".")[0] elif os_type.startswith('freebsd'): # eg "9.3-RC3-p1" os_ver = os_ver.partition("-")[0] os_ver = os_ver.partition(".")[0] elif platform.win32_ver()[1]: os_ver = platform.win32_ver()[1] else: # Cases known to fall here: Cygwin python os_ver = '' return os_type, os_ver
def print_basic_debug_info(out=None): if out is None: out = sys.stdout out = functools.partial(prints, file=out) import platform from calibre.constants import (__appname__, get_version, isportable, isosx, isfrozen, is64bit) out(__appname__, get_version(), 'Portable' if isportable else '', 'isfrozen:', isfrozen, 'is64bit:', is64bit) out(platform.platform(), platform.system(), platform.architecture()) if iswindows and not is64bit: try: import win32process if win32process.IsWow64Process(): out('32bit process running on 64bit windows') except: pass out(platform.system_alias(platform.system(), platform.release(), platform.version())) out('Python', platform.python_version()) try: if iswindows: out('Windows:', platform.win32_ver()) elif isosx: out('OSX:', platform.mac_ver()) else: out('Linux:', platform.linux_distribution()) except: pass
def get_os_info(): """ Get Operating System type/distribution and major version :returns: (os_name, os_version) :rtype: `tuple` of `str` """ info = platform.system_alias(platform.system(), platform.release(), platform.version()) os_type, os_ver, _ = info os_type = os_type.lower() if os_type.startswith("linux"): info = platform.linux_distribution() # On arch, platform.linux_distribution() is reportedly ('','',''), # so handle it defensively if info[0]: os_type = info[0] if info[1]: os_ver = info[1] elif os_type.startswith("darwin"): os_ver = subprocess.Popen(["sw_vers", "-productVersion"], stdout=subprocess.PIPE).communicate()[0] os_ver = os_ver.partition(".")[0] elif os_type.startswith("freebsd"): # eg "9.3-RC3-p1" os_ver = os_ver.partition("-")[0] os_ver = os_ver.partition(".")[0] elif platform.win32_ver()[1]: os_ver = platform.win32_ver()[1] else: # Cases known to fall here: Cygwin python os_ver = "" return os_type, os_ver
def _merge_sysinfo(self, parser, properties): """Merge the platform information properties into the configuration.""" system, _, release, version, machine, processor = platform.uname() system, release, version = platform.system_alias(system, release, version) self.properties['machine'] = machine self.properties['processor'] = processor self.properties['os'] = system self.properties['family'] = os.name self.properties['version'] = release mapping = {'machine': ('machine', 'name'), 'processor': ('machine', 'processor'), 'os': ('os', 'name'), 'family': ('os', 'family'), 'version': ('os', 'version')} for key, (section, option) in mapping.items(): if parser.has_option(section, option): value = parser.get(section, option) if value is not None: self.properties[key] = value if properties: for key, value in properties.items(): if key in mapping: self.properties[key] = value
def print_basic_debug_info(out=None): if out is None: out = sys.stdout out = functools.partial(prints, file=out) import platform from contextlib import suppress from calibre.constants import (__appname__, get_version, isportable, ismacos, isfrozen, is64bit) from calibre.utils.localization import set_translators out(__appname__, get_version(), 'Portable' if isportable else '', 'embedded-python:', isfrozen, 'is64bit:', is64bit) out(platform.platform(), platform.system(), platform.architecture()) if iswindows and not is64bit: from calibre_extensions.winutil import is_wow64_process with suppress(Exception): if is_wow64_process(): out('32bit process running on 64bit windows') out(platform.system_alias(platform.system(), platform.release(), platform.version())) out('Python', platform.python_version()) try: if iswindows: out('Windows:', platform.win32_ver()) elif ismacos: out('OSX:', platform.mac_ver()) else: out('Linux:', platform.linux_distribution()) except: pass out('Interface language:', unicode_type(set_translators.lang)) from calibre.customize.ui import has_external_plugins, initialized_plugins if has_external_plugins(): names = ('{0} {1}'.format(p.name, p.version) for p in initialized_plugins() if getattr(p, 'plugin_path', None) is not None) out('Successfully initialized third party plugins:', ' && '.join(names))
def platform_select(options, test_platform=()): ''' Find the current platform Matches the output from platform.system_alias, ``system``, ``release`` and ``version`` against 0-3 regular expressions and returns the first match. Given that the platform is (from :func:`platform.system_alias`):: ('Linux', '2.6.9-11.ELsmp', '#1 SMP Fri May 20 18:26:27 EDT 2005') A list of options like this: [ # Match system and release (['Linux', '2.6.\d\d.*'], 'linux_new'), # Match only system (['Linux'] , 'linux_generic'), ] Would return ``linux_generic``. :arg options: List of platforms to match against, every entry must have the format:: (list([system match, [release match, [version match]]]), <return value>) If the list is empty all platforms would match. If more the one options match the first one is selected :arg test_platform: For testing purposes, send in a tuple in the same format as :func:`platform.system_alias()` ''' if test_platform: system, release, version = test_platform else: system, release, version = this_platform = platform.system_alias( platform.system(), platform.release(), platform.version()) for option in options: match, select = option # Create a list of None for the ignored system specifiers match_padding = [None] * (3 - len(match)) match_system, match_release, match_version =\ (match + match_padding) if match_system and not re.match(match_system, system): continue if match_release and not re.match(match_release, release): continue if match_version and not re.match(match_version, version): continue return select return None
def run(): # Well, this is easy. platform_info = platform.system_alias(platform.system(), platform.release(), platform.version()) return { 'OS': 'System: {} || Release: {} || Version: {}'.format(platform_info[0], platform_info[1], platform_info[2]), 'CPU Type': '{} x {}'.format(platform.processor(), multiprocessing.cpu_count()), }
class GenerationInfo: created: DateTime = field(default_factory=lambda: datetime.now()) system_alias: Tuple[AnyStr, AnyStr, AnyStr] = field( default_factory=lambda: platform.system_alias(platform.system( ), platform.release(), platform.version())) python_version: AnyStr = field( default_factory=lambda: platform.python_version()) config_vars: Dict[AnyStr, object] = field( default_factory=sysconfig.get_config_vars)
def report_failure(self, name, msg, show_traceback=True): "Report a test failure, with some useful context." tb = _traceback.extract_tb(_sys.exc_info()[2]) # Move up the traceback until we get to the line in the test # function which caused the failure. for line in xrange(1, len(tb) + 1): if tb[-line][2] == 'test_' + name: break # Display the context in the text function. filepath, linenum, functionname, text = tb[-line] filename = _os.path.basename(filepath) self._out.ensure_space() self._out.write_colour("#red#FAILED##\n") if self._verbose > 0: if self._context is None: context = '' else: context = ", when %s" % self._context firstline = "%s:%d" % (filename, linenum) self._out.write("\n%s:%s%s\n" % (firstline, msg, context)) # Display sourcecode lines lines = open(filepath).readlines() startline = max(linenum - 3, 0) endline = min(linenum + 2, len(lines)) for num in range(startline, endline): if num + 1 == linenum: self._out.write('->') else: self._out.write(' ') self._out.write("%4d %s\n" % (num + 1, lines[num].rstrip())) # Display the traceback if show_traceback: self._out.write("Traceback (most recent call last):\n") for line in _traceback.format_list(tb): self._out.write(line.rstrip() + '\n') self._out.write('\n') # Display some information about the xapian version and platform self._out.write("Xapian version: %s\n" % _xapian.version_string()) try: import platform platdesc = "%s %s (%s)" % platform.system_alias( platform.system(), platform.release(), platform.version()) self._out.write("Platform: %s\n" % platdesc) except: pass self._out.write( '\nWhen reporting this problem, please quote all the preceding lines from\n"%s" onwards.\n\n' % firstline) self._out.flush()
def get_system() -> List: """ Detect Linux platform. Not used at this stage. It is meant to enable password encryption in distros that can handle this well. """ system = platform.system_alias(platform.system(), platform.release(), platform.version()) return [system, detect_desktop_environment()]
def test_sysinfo_defaults(self): config = Configuration() self.assertEqual(platform.machine(), config['machine']) self.assertEqual(platform.processor(), config['processor']) system, release, version = platform.system_alias( platform.system(), platform.release(), platform.version()) self.assertEqual(system, config['os']) self.assertEqual(os.name, config['family']) self.assertEqual(release, config['version'])
def detect_os(): global illegal_chars from platform import system,release,version,system_alias os_name = system_alias(system(),release(),version())[0].lower() if os_name=="windows": illegal_chars = [':','*','?','"','<','>','|'] elif os_name=="linux": illegal_chars = [] if format_symbol in illegal_chars: illegal_chars.remove(format_symbol)
def GetSystemInformation(self): LogManager.Log.warning("Reading system information about CPUs") results = dict() results['Processor'] = platform.processor() results['ProcessorType'] = platform.machine() results['OS'] = platform.system() results['OSRelease'] = platform.release() results['OSVersion'] = platform.version() results['OSAlias'] = platform.system_alias(results['OS'], results['OSVersion'], results['OSVersion']) return results
def getCharsetId(): (system, release, version) = platform.system_alias(platform.system(), platform.release(), platform.version()) data = re.split("_|\.|@?", locale.setlocale(locale.LC_ALL, '')) data[2] = data[2].replace("_", "-").upper() if data[2] in CHARSETS: return CHARSETS[data[2]] elif (re.match("windows", system, re.I) is not None or re.match("windows", release, re.I) is not None) and "MS" + data[2] in CHARSETS: return CHARSETS["MS" + data[2]] else: return 0
def platform_id(self): try: import platform x = platform.uname() return platform.system_alias(x[0], x[2], x[3]) except (ImportError, AttributeError): try: x = os.uname() return (x[0], x[2], x[3]) except AttributeError: return (sys.platform, "unknown", "unknown")
def get_python_os_info(pretty: bool = False) -> Tuple[str, str]: """ Get Operating System type/distribution and major version using python platform module :param bool pretty: If the returned OS name should be in longer (pretty) form :returns: (os_name, os_version) :rtype: `tuple` of `str` """ info = platform.system_alias(platform.system(), platform.release(), platform.version()) os_type, os_ver, _ = info os_type = os_type.lower() if os_type.startswith('linux') and _USE_DISTRO: distro_name, distro_version = distro.name() if pretty else distro.id( ), distro.version() # On arch, these values are reportedly empty strings so handle it # defensively # so handle it defensively if distro_name: os_type = distro_name if distro_version: os_ver = distro_version elif os_type.startswith('darwin'): try: proc = subprocess.run( ["/usr/bin/sw_vers", "-productVersion"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False, universal_newlines=True, env=env_no_snap_for_external_calls(), ) except OSError: proc = subprocess.run( ["sw_vers", "-productVersion"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False, universal_newlines=True, env=env_no_snap_for_external_calls(), ) os_ver = proc.stdout.rstrip('\n') elif os_type.startswith('freebsd'): # eg "9.3-RC3-p1" os_ver = os_ver.partition("-")[0] os_ver = os_ver.partition(".")[0] elif platform.win32_ver()[1]: os_ver = platform.win32_ver()[1] else: # Cases known to fall here: Cygwin python os_ver = '' return os_type, os_ver
def get_charset_id(): (system, release, version) = platform.system_alias(platform.system(), platform.release(), platform.version()) data = re.split("_|\.|@?", locale.setlocale(locale.LC_ALL, '')) data[2] = data[2].replace("_", "-").upper() data[2] = data[2].replace("UTF8", "UTF-8") if data[2] in CHARSETS: return CHARSETS[data[2]] if (re.match("windows", system, re.I) or re.match("windows", release, re.I)) and "MS" + data[2] in CHARSETS: return CHARSETS["MS" + data[2]] return 0
def test_sysinfo_defaults(self): config = Configuration() self.assertEqual(platform.machine(), config['machine']) self.assertEqual(platform.processor(), config['processor']) system, release, version = platform.system_alias(platform.system(), platform.release(), platform.version()) self.assertEqual(system, config['os']) self.assertEqual(os.name, config['family']) self.assertEqual(release, config['version'])
def detect_os(): global illegal_chars,correct_filename from platform import system,release,version,system_alias os_name = system_alias(system(),release(),version())[0].lower() if os_name=="windows": illegal_chars = [':','*','?','"','<','>','|','\0'] current_format.set_correct_filename(correct_filename) elif os_name=="linux": illegal_chars = ['\0'] current_format.set_correct_filename(lambda string : string) if Format.symbol in illegal_chars: illegal_chars.remove(Format.symbol)
def run_debug_gui(logpath): import time, platform time.sleep(3) # Give previous GUI time to shutdown fully and release locks from calibre.constants import __appname__, __version__, isosx print __appname__, _('Debug log') print __appname__, __version__ print platform.platform() print platform.system() print platform.system_alias(platform.system(), platform.release(), platform.version()) print 'Python', platform.python_version() try: if iswindows: print 'Windows:', platform.win32_ver() elif isosx: print 'OSX:', platform.mac_ver() else: print 'Linux:', platform.linux_distribution() except: pass from calibre.gui2.main import main main(['__CALIBRE_GUI_DEBUG__', logpath])
def get_platform_id(): (system, release, version) = platform.system_alias(platform.system(), platform.release(), platform.version()) if re.match("windows", system, re.I) or re.match("windows", release, re.I): return PLATFORMS['MS_WINDOWS'] if re.match("solaris", system, re.I) or re.match("solaris", release, re.I): return PLATFORMS['SOLARIS'] if re.match("aix", system, re.I) or re.match("aix", release, re.I): return PLATFORMS['AIX'] if re.match("hpux", system, re.I) or re.match("hpux", release, re.I): return PLATFORMS['HP_UX'] if re.match("linux", system, re.I) or re.match("linux", release, re.I): return PLATFORMS['LINUX'] return 0
def systemInfo(): ''' Returns a tuple containing the following information: - system name (e.g. Darwin, Windows, Ubuntu etc.) - release (e.g.: 12.04 for Ubuntu, 11.4.0 for Darwin etc.) - version The difference between platform.system_alias() and this function is that this function returns the Linux distribution name and version instead of 'Linux' and the kernel version. ''' sys, rel, ver = system_alias(system(), release(), version()) if sys == 'Linux': sys, rel, _relname = linux_distribution() return (sys, rel, ver)
def mininginfo(): file_info = os.stat(fpath) print "file_info:",file_info last_modified = file_info.st_mtime dt = datetime.datetime.fromtimestamp(last_modified) print "last_modified_time:",dt.strftime("%Y-%m-%d %H:%M:%S") # Print最終更新日時 #OS等paltform情報を読み取る(PC固有情報になるのか?) #参考?:http://docs.python.jp/2.6/library/platform.html print 'machine:', print platform.machine() print platform.node() print platform.platform(0,0) print platform.processor() print platform.python_build() sys_info =platform.system() sys_re = platform.release() sys_ver = platform.version() print sys_info,sys_re,sys_ver print platform.system_alias(sys_info, sys_re, sys_ver) print platform.uname() print os.getpid()
def get_python_os_info(pretty=False): """ Get Operating System type/distribution and major version using python platform module :param bool pretty: If the returned OS name should be in longer (pretty) form :returns: (os_name, os_version) :rtype: `tuple` of `str` """ info = platform.system_alias(platform.system(), platform.release(), platform.version()) os_type, os_ver, _ = info os_type = os_type.lower() if os_type.startswith('linux') and _USE_DISTRO: info = distro.linux_distribution(pretty) # On arch, distro.linux_distribution() is reportedly ('','',''), # so handle it defensively if info[0]: os_type = info[0] if info[1]: os_ver = info[1] elif os_type.startswith('darwin'): try: proc = subprocess.Popen( ["/usr/bin/sw_vers", "-productVersion"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, env=env_no_snap_for_external_calls(), ) except OSError: proc = subprocess.Popen( ["sw_vers", "-productVersion"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, env=env_no_snap_for_external_calls(), ) os_ver = proc.communicate()[0].rstrip('\n') elif os_type.startswith('freebsd'): # eg "9.3-RC3-p1" os_ver = os_ver.partition("-")[0] os_ver = os_ver.partition(".")[0] elif platform.win32_ver()[1]: os_ver = platform.win32_ver()[1] else: # Cases known to fall here: Cygwin python os_ver = '' return os_type, os_ver
def getPlatformId(): (system, release, version) = platform.system_alias(platform.system(), platform.release(), platform.version()) if re.match("windows", system, re.I) is not None or re.match("windows", release, re.I) is not None: return PLATFORMS['MS_WINDOWS'] elif re.match("solaris", system, re.I) is not None or re.match("solaris", release, re.I) is not None: return PLATFORMS['SOLARIS'] elif re.match("aix", system, re.I) is not None or re.match("aix", release, re.I) is not None: return PLATFORMS['AIX'] elif re.match("hpux", system, re.I) is not None or re.match("hpux", release, re.I) is not None: return PLATFORMS['HP_UX'] elif re.match("linux", system, re.I) is not None or re.match("linux", release, re.I) is not None: return PLATFORMS['LINUX'] else: return 0
def __init__(self): ''' Initialize the class. Return standard runtime environment. ''' self.theArchitecture = platform.architecture(executable=sys.executable, bits='', linkage='') self.theMachine = platform.machine() self.theNode = platform.node() if platformAvailable: # Introduced with Python 2.3 self.thePlatform = platform.platform(aliased=1, terse=0) else: # NOT Introduced until Python 2.3 self.thePlatform = '' if platformAvailable: try: # Introduced with Python 2.6 self.thePython_branch = platform.python_branch() self.thePython_implementation = \ platform.python_implementation() self.thePython_revision = platform.python_revision() except Exception as errorCode: # NOT Introduced until Python 2.6 self.thePython_branch = '' self.thePython_implementation = '' self.thePython_revision = '' else: # NOT Introduced until Python 2.6 self.thePython_branch = '' self.thePython_implementation = '' self.thePython_revision = '' self.theProcessor = platform.processor() self.thePython_build = platform.python_build() self.thePython_compiler = platform.python_compiler() self.thePython_version = platform.python_version() self.thePython_version_tuple = platform.python_version_tuple() self.theRelease = platform.release() self.theSystem = platform.system() self.theUname = platform.uname() self.theVersion = platform.version() self.theSystem_alias = platform.system_alias(self.theSystem, self.theRelease, self.theVersion)
def run_debug_gui(logpath): import time, platform time.sleep(3) # Give previous GUI time to shutdown fully and release locks from calibre.constants import __appname__, __version__, isosx print __appname__, _("Debug log") print __appname__, __version__ print platform.platform() print platform.system() print platform.system_alias(platform.system(), platform.release(), platform.version()) print "Python", platform.python_version() try: if iswindows: print "Windows:", platform.win32_ver() elif isosx: print "OSX:", platform.mac_ver() else: print "Linux:", platform.linux_distribution() except: pass from calibre.gui2.main import main main(["__CALIBRE_GUI_DEBUG__", logpath])
def __init__(self): import platform system_alias_name = platform.system_alias(platform.system(), platform.release(), platform.version())[0] or _("Computer") Topic.__init__(self, system_alias_name, uri="topic://Computer", icon="computer") from gimmie_running import ComputerRunningSource self.set_running_source_factory(lambda: ComputerRunningSource()) self.update_time_timeout_id = None self.current_time = 0
def get_python_os_info(): """ Get Operating System type/distribution and major version using python platform module :returns: (os_name, os_version) :rtype: `tuple` of `str` """ info = platform.system_alias( platform.system(), platform.release(), platform.version() ) os_type, os_ver, _ = info os_type = os_type.lower() if os_type.startswith('linux'): info = platform.linux_distribution() # On arch, platform.linux_distribution() is reportedly ('','',''), # so handle it defensively if info[0]: os_type = info[0] if info[1]: os_ver = info[1] elif os_type.startswith('darwin'): try: proc = subprocess.Popen( ["/usr/bin/sw_vers", "-productVersion"], stdout=subprocess.PIPE, universal_newlines=True, ) except OSError: proc = subprocess.Popen( ["sw_vers", "-productVersion"], stdout=subprocess.PIPE, universal_newlines=True, ) os_ver = proc.communicate()[0].rstrip('\n') elif os_type.startswith('freebsd'): # eg "9.3-RC3-p1" os_ver = os_ver.partition("-")[0] os_ver = os_ver.partition(".")[0] elif platform.win32_ver()[1]: os_ver = platform.win32_ver()[1] else: # Cases known to fall here: Cygwin python os_ver = '' return os_type, os_ver
def SystemVersion(): #from sys import platform as _platform import platform #import os from collections import namedtuple ver = namedtuple("ver", [ "machine", "network_name", "processor_name", "python_compiler", "python_implementation", "python_version", "python_version_tuple", "system_release", "system_system", "system_version", "system_tuple", "system_uname", "platform_info" ]) platform_information = "" try: # Java Platform platform_information = platform.java_ver() if platform_information[0] == '': raise Exception() except: try: # Windows Platform platform_information = platform.win32_ver() if platform_information[0] == '': raise Exception() except: try: # Mac OS Platform platform_information = platform.mac_ver() if platform_information[0] == '': raise Exception() except: # Unknown platform_information = () osversion = ver(machine=platform.machine(), network_name=platform.node(), processor_name=platform.processor(), python_compiler=platform.python_compiler(), python_implementation=platform.python_implementation(), python_version=platform.python_version(), python_version_tuple=platform.python_version_tuple(), system_system=platform.system(), system_release=platform.release(), system_version=platform.version(), system_tuple=platform.system_alias(platform.system(), platform.release(), platform.version()), system_uname=platform.uname(), platform_info=platform_information) return osversion
def system_identify(): if build_os == 'Windows': release, version, csd, ptype = platform.win32_ver() plat_str = 'release {}, version {}, service pack {}, type {}'.format( release, version, csd, ptype) elif build_os == 'Linux': # Avoid the deprecated platform.dist(). lib, version = platform.libc_ver() plat_str = '{} version {}'.format(lib, version) elif build_os == 'OS_X': release, (version, dev_stage, non_release_version), machine = \ platform.mac_ver() plat_str = ('release {}, dev stage {}, non-relase version {}, machine ' '{}'.format(release, version, dev_stage, non_release_version, machine)) system, release, version = platform.system_alias(platform.system(), platform.release(), platform.version()) flush_print('Python {}, OS {}, platform {} {} - {}'.format(sys.version, os.name, system, release, version, plat_str))
def update_attributes(self): system, release, version = platform.system_alias(platform.system(), platform.release(), platform.version()) uptime=time.time() - self.creation_time uphours=int(uptime/3600) updays=int(uphours/24) uphours=uphours-updays*24 uptime=f"{updays}d, {uphours}h" attributes={ 'System': system, 'Release': release, 'Version': version, 'Host': socket.gethostname(), 'MAC': self.mac_address, 'IP': self.ip_address, 'Sensor uptime': uptime, 'Sensor version': HA_VERSION } attribs_payload=json.dumps(attributes) self.mqtt.publish(self.attributes_topic, attribs_payload)
def print_basic_debug_info(out=None): if out is None: out = sys.stdout out = functools.partial(prints, file=out) import platform from calibre.constants import __appname__, get_version, isportable, isosx out(__appname__, get_version(), 'Portable' if isportable else '') out(platform.platform(), platform.system()) out(platform.system_alias(platform.system(), platform.release(), platform.version())) out('Python', platform.python_version()) try: if iswindows: out('Windows:', platform.win32_ver()) elif isosx: out('OSX:', platform.mac_ver()) else: out('Linux:', platform.linux_distribution()) except: pass
def runBenchmarks(infilename,outfilename,sample_count,timeout,memout,product,buildenv,number_workers = cpu_count()): import platform runenv = { "os" : " ".join(platform.system_alias(platform.system(),platform.release(),platform.version())), "arch" : platform.machine(), "processor" : platform.processor() } bf = BenchmarkFile(infilename) runqueue = RunQueue(number_workers) for b in bf.benchmarks: endTaskHandler = EndTaskHandler(b,runqueue,sample_count) for i in range(0,sample_count): runqueue.add(b,endTaskHandler,maxtime=timeout,maxmem=memout) runqueue.wait() f = open(outfilename,"w") f.write(getBenchmarksXML(bf,product,buildenv,runenv)) f.close()
def print_basic_debug_info(out=None): if out is None: out = sys.stdout out = functools.partial(prints, file=out) import platform from calibre.constants import __appname__, get_version, isportable, isosx, isfrozen, is64bit out(__appname__, get_version(), "Portable" if isportable else "", "isfrozen:", isfrozen, "is64bit:", is64bit) out(platform.platform(), platform.system(), platform.architecture()) out(platform.system_alias(platform.system(), platform.release(), platform.version())) out("Python", platform.python_version()) try: if iswindows: out("Windows:", platform.win32_ver()) elif isosx: out("OSX:", platform.mac_ver()) else: out("Linux:", platform.linux_distribution()) except: pass
def system_identify(): if build_os == 'Windows': release, version, csd, ptype = platform.win32_ver() plat_str = 'release {}, version {}, service pack {}, type {}'.format( release, version, csd, ptype) elif build_os == 'Linux': # Avoid the deprecated platform.dist(). lib, version = platform.libc_ver() plat_str = '{} version {}'.format(lib, version) elif build_os == 'OS_X': release, (version, dev_stage, non_release_version), machine = \ platform.mac_ver() plat_str = ('release {}, dev stage {}, non-relase version {}, machine ' '{}'.format(release, version, dev_stage, non_release_version, machine)) system, release, version = platform.system_alias(platform.system(), platform.release(), platform.version()) flush_print('Python {}, OS {}, platform {} {} - {}'.format( sys.version, os.name, system, release, version, plat_str))
def do_printenv(cls, line): """ Print information about the runtime environment. Run in the shell with: printenv """ logger = logging.getLogger(__name__) if line is None: # Put this here to get rid of PyCharm warning about line not being used pass print("Python version (sys.version) = " + sys.version) # Print value of environment variables that impact Python, alphabetized. # - skip the more esoteric ones # - See: https://docs.python.org/2/using/cmdline.html env_vars = [ "PYTHONBYTECODE", "PYTHONDEBUG", "PYTHONHOME", "PYTHONHTTPSVERIFY", "PYTHONOPTIMIZE", "PYTHONPATH", "PYTHONSTARTUP", "PYTHONUSERBASE", "PYTHONUSERSITE", "PYTHONVERBOSE" ] for env_var in env_vars: try: print(env_var + " = " + os.environ[env_var]) except KeyError: print(env_var + " = not defined") print("os.getcwd() = " + os.getcwd()) print("platform.architecture = " + str(platform.architecture())) print("platform.machine = " + platform.machine()) print("platform.node = " + platform.node()) print("platform.platform = " + platform.platform()) print("platform.processor = " + platform.processor()) print("platform.system = " + platform.system()) print("platform.system_alias = " + str( platform.system_alias(platform.system(), platform.release(), platform.version()))) print("user = "******"GeoProcessor properties:") for property_name, property_value in processor.properties.items(): print(property_name + " = " + str(property_value))
def test_sysinfo_configfile_partial_override(self): inifd, ininame = tempfile.mkstemp(prefix='bitten_test') try: os.write(inifd, """ [machine] name = MACHINE [os] name = OS """) os.close(inifd) config = Configuration(ininame) self.assertEqual('MACHINE', config['machine']) self.assertEqual('OS', config['os']) # Remaining options should be set to default value system, release, version = platform.system_alias( platform.system(), platform.release(), platform.version()) self.assertEqual(platform.processor(), config['processor']) self.assertEqual(os.name, config['family']) self.assertEqual(release, config['version']) finally: os.remove(ininame)
def __init__(self, url, logging_object, language_object): """ This is the __init__ methode... Nothing more information needed. Variables: - url ``string`` the url from which the data will be extracted from. """ self.url = url self.logging_object = logging_object self.language_object = language_object self.webpage = "" self._get_webpage_() # the headers for the webrequest self._headers = { 'User-agent': (("{AppName}/{Version}({Platform})" "Python-urllib/{PythonBuild} from {Hosted}" ).format( AppName=gobjects.__AppName__, Version=gobjects.__version__, Platform=('; '.join( platform.system_alias( platform.system(), platform.release(), platform.version() ) ) ), PythonBuild=platform.python_build(), Hosted=gobjects.__hosted__ ) ), "Content-Type": "application/x-www-form-urlencoded;charset=utf-8", "Accept-Encoding": "gzip,deflate" }
def test_sysinfo_configfile_partial_override(self): inifd, ininame = tempfile.mkstemp(prefix='bitten_test') try: os.write(inifd, """ [machine] name = MACHINE [os] name = OS """) os.close(inifd) config = Configuration(ininame) self.assertEqual('MACHINE', config['machine']) self.assertEqual('OS', config['os']) # Remaining options should be set to default value system, release, version = platform.system_alias(platform.system(), platform.release(), platform.version()) self.assertEqual(platform.processor(), config['processor']) self.assertEqual(os.name, config['family']) self.assertEqual(release, config['version']) finally: os.remove(ininame)
def test_system_alias(self): res = platform.system_alias( platform.system(), platform.release(), platform.version(), )
('version', '-'.join(platform.win32_ver()[1:3])) ]) elif sys.platform.startswith('java'): _name, _ver, _arch = platform.java_ver()[-1] _METADATA['os'] = SON([ # Linux, Windows 7, Mac OS X, etc. ('type', _name), ('name', _name), # x86, x86_64, AMD64, etc. ('architecture', _arch), # Linux kernel version, OSX version, etc. ('version', _ver) ]) else: # Get potential alias (e.g. SunOS 5.11 becomes Solaris 2.11) _aliased = platform.system_alias( platform.system(), platform.release(), platform.version()) _METADATA['os'] = SON([ ('type', platform.system()), ('name', ' '.join([part for part in _aliased[:2] if part])), ('architecture', platform.machine()), ('version', _aliased[2]) ]) if platform.python_implementation().startswith('PyPy'): _METADATA['platform'] = ' '.join( (platform.python_implementation(), '.'.join(imap(str, sys.pypy_version_info)), '(Python %s)' % '.'.join(imap(str, sys.version_info)))) elif sys.platform.startswith('java'): _METADATA['platform'] = ' '.join( (platform.python_implementation(),
def main(): p = {} if platform.system() == 'Darwin': #osx try: #someday, the next line may be helpful for OSX p['os'] = platform.system_alias(platform.system(),platform.release(),platform.mac_ver())[0] or None p['type'] = 'Darwin' p['release'] = platform.mac_ver()[0] or None p['platform'] = platform.platform() or None p['python_version'] = platform.python_version() or None p['current_uid'] = pwd.getpwuid(os.getuid())[2] p['current_gid'] = pwd.getpwuid(os.getuid())[3] p['current_user'] = pwd.getpwuid(os.getuid())[0] p['current_user_group'] = grp.getgrgid(pwd.getpwnam(p['current_user']).pw_gid).gr_name p['current_user_desktop'] = os.path.join(os.path.expanduser('~'), 'Desktop') p['current_user_homedir'] = os.path.expanduser(('~')) p['tmp_dir'] = tempfile.gettempdir() #Dot is there as a hack until joining ~ and a dir does more than just give [1:] p['current_user_plist_dir'] = os.path.join(os.path.expanduser('~'),'./Library/LaunchAgents/') except IOError: return_error('Could not get more specific information for Darwin-based platform') elif platform.system() == 'Linux': try: p['os'] = platform.linux_distribution()[0] or None p['type'] = 'Linux' p['release'] = platform.linux_distribution()[1] or None p['platform'] = platform.platform() or None p['python_version'] = platform.python_version() or None p['current_uid'] = pwd.getpwuid(os.getuid())[2] p['current_gid'] = pwd.getpwuid(os.getuid())[3] p['current_user'] = pwd.getpwuid(os.getuid())[0] p['current_user_group'] = grp.getgrgid(pwd.getpwnam(p['current_user']).pw_gid).gr_name p['current_user_desktop'] = subprocess.check_output(['xdg-user-dir', 'DESKTOP']) p['tmp_dir'] = tempfile.gettempdir() except: return_error('Could not get more specific information for Linux-based platform') elif platform.system() == 'Windows': try: p['os'] = "{0} {1}".format(platform.win32_ver()[0],platform.win32_ver()[2] or '') or None p['type'] = 'Windows' p['release'] = platform.win32_ver()[0] or None p['platform'] = platform.platform() or None p['python_version'] = platform.python_version() or None p['current_user_desktop'] = os.path.join(os.path.expanduser('~'), 'Desktop') #I don't know the Windows equiv of getting UID/GID.. last I checked, it was terrible and I don't #really care that much about Windows as long as Microsoft makes simple things annoying. p['tmp_dir'] = tempfile.gettempdir() except: return_error('Could not get more specific information for Windows-based platform') else: try: p['os'] = platform.linux_distribution()[0] or None p['type'] = 'unknown' p['release'] = platform.linux_distribution()[1] or None p['platform'] = platform.platform() or None p['python_version'] = platform.python_version() or None p['tmp_dir'] = tempfile.gettempdir() or None p['current_uid'] = p['current_gid'] = None p['current_user'] = p['current_user_group'] = p['current_user_desktop'] = None except: return_error('Could not get platform information.') return p
def load_machine_vars(self, machine_var_data_manager: DataManager, current_time) -> None: """Load machine vars from data manager.""" self.machine_var_data_manager = machine_var_data_manager for name, settings in (iter( self.machine_var_data_manager.get_data().items())): if not isinstance(settings, dict) or "value" not in settings: continue if ('expire' in settings and settings['expire'] and settings['expire'] < current_time): continue self.set_machine_var(name=name, value=settings['value']) self._load_initial_machine_vars() # Create basic system information machine variables self.set_machine_var(name="mpf_version", value=mpf_version) '''machine_var: mpf_version desc: Full version string for MPF. ''' self.set_machine_var(name="mpf_extended_version", value=mpf_extended_version) '''machine_var: mpf_extended_version desc: Extended version string for MPF. Contains show and bcp version as well. ''' self.set_machine_var(name="python_version", value=python_version()) '''machine_var: python_version desc: Python version. ''' self.set_machine_var(name="platform", value=platform(aliased=True)) '''machine_var: platform desc: A single string identifying the underlying platform with as much useful information as possible. ''' platform_info = system_alias(system(), release(), version()) self.set_machine_var(name="platform_system", value=platform_info[0]) '''machine_var: platform_system desc: Your system (Linux/Windows/Mac). ''' self.set_machine_var(name="platform_release", value=platform_info[1]) '''machine_var: platform_release desc: Release of your operating system. ''' self.set_machine_var(name="platform_version", value=platform_info[2]) '''machine_var: platform_version desc: Version of your operating system. ''' self.set_machine_var(name="platform_machine", value=platform_machine()) '''machine_var: platform_machine
platforminfo['machine'] = platform.machine() platforminfo['node'] = platform.node() platforminfo['platform'] = platform.platform(aliased=0, terse=0) platforminfo['processor'] = platform.processor() platforminfo['architecture'] = platform.architecture() platforminfo['python_build'] = platform.python_build() platforminfo['python_version'] = platform.python_version() platforminfo['python_compiler'] = platform.python_compiler() platforminfo['python_branch'] = platform.python_branch() platforminfo['python_implementation'] = platform.python_implementation() platforminfo['python_revision'] = platform.python_revision() platforminfo['python_version_tuple'] = platform.python_version_tuple() platforminfo['release'] = platform.release() platforminfo['system'] = platform.system() platforminfo['version'] = platform.version() platforminfo['system_alias'] = platform.system_alias( platforminfo['system'], platforminfo['release'], platforminfo['version']) platforminfo['uname'] = platform.uname() platforminfo['linux_distribution'] = platform.linux_distribution() return render_to_response( "home.html", { 'request': request, 'osinfo': osinfo, 'hostinfo': hostinfo, 'envinfo': envinfo, 'platforminfo': platforminfo })
# TODO probably should obey pep8 # TODO logging # TODO test mode import os import sys from platform import system, system_alias, release, version, linux_distribution if sys.version_info < (2, 6): print "I require 2.6 or higher" sys.exit(1) # Determine OS type so I can use specific dotfiles # think about how to set this variable _os, release, version = system_alias(system(), release(), version()) if _os.lower() == 'linux': myos = 'linux' elif _os.lower() == 'darwin': myos = 'osx' elif _os.lower() == 'win32': myos = 'windows' else: # i dunno you should check this first print "I'm not sure what OS you're running, lets quit." sys.exit(1) HOMEDIR = os.path.expanduser('~') DIR = '%s/.dotfiles' % HOMEDIR OLDDIR = '%s/.dotfiles_old' % HOMEDIR SECRETS = 'url of secret repo' # TODO set this, obv
def env(): """ Returns a simple to use dictionary of common operating system details""" p = {} p['platform'] = platform.platform() or None p['python_version'] = platform.python_version() or None try: p['python_major_version'] = p['python_version'][0] except TypeError: p['python_major_version'] = None p['python_version_feature_branch'] = '.'.join(platform.python_version().split('.')[0:2]) or None p['python_installed_packages'] = ["%s==%s" % (pkg.key, pkg.version) for pkg in pip.get_installed_distributions()] p['homedir'] = os.path.join(os.path.expanduser('~')) p['current_user_desktop'] = os.path.join(p['homedir'], 'Desktop') or None p['tmp_dir'] = tempfile.gettempdir() # Might fail on Windows. Open a PR or issue on github if this is important to you. # This should probably get cleaned up by separating the getgrpid from getpwuid, but AFAIK, it's pass/fail try: pwuid = pwd.getpwuid(os.getuid()) p['current_uid'] = pwuid[2] p['current_gid'] = pwuid[3] p['current_user'] = pwuid[0] p['current_user_group'] = grp.getgrgid(pwd.getpwnam(p['current_user']).pw_gid).gr_name except NameError: try: p['current_user'] = getpass.getuser() except AttributeError: # User is on some unknown OS p['current_user'] = None finally: p['current_uid'] = p['current_gid'] = p['current_user_group'] = None # Start OS-specific calls. if platform.system() == 'Darwin': try: p['type'] = 'Darwin' p['os'] = platform.system_alias(platform.system(), platform.release(), platform.mac_ver())[0] or None p['release'] = platform.mac_ver()[0] or None except Exception as e: raise Exception('Fatal error retrieving OS details on OSX: {}'.format(e)) elif platform.system() == 'Linux': try: dist_info = platform.linux_distribution() p['type'] = 'Linux' p['os'] = dist_info[0] or None p['release'] = dist_info[1] or None except Exception as e: raise Exception('Fatal error retrieving OS details on Linux: {}'.format(e)) elif platform.system() == 'Windows': try: p['type'] = 'Windows' p['os'] = str(platform.system() + platform.release()) or None p['release'] = platform.win32_ver()[0] or None except Exception as e: raise Exception('Fatal error retrieving OS details on Windows: {}'.format(e)) else: # unknown OS. likely odd/new variant of linux/unix or windows # linx/unix is more important, so we default to that: try: dist_info = platform.linux_distribution() p['os'] = dist_info[0] or None p['type'] = 'unknown' p['release'] = dist_info[1] or None except Exception as e: raise NotImplementedError('Could not get platform information for unknown OS: {}'.format(e)) return p
#!/usr/bin/env python # encoding: utf-8 """ 这个文件中记录了所有的全局静态配置变量。现在只有named.conf所属路径和nameddb目录存储路径。 """ import re import os import platform import pwd import sys import errno system, _, release, version, machine, processor = platform.uname() system, release, version = platform.system_alias(system, release, version) release = re.compile(r"^\d+.\d+").search(release).group() # 安装路径,是否能传进来?暂时写成根据相对路径 installdir = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) # 这里记录了bind启动的chroot根目录 chroot_path = "/var/named" # 这里记录了named.conf所存储的路径 namedconf = "/etc/namedb" # 这是bind的启动脚本 namedstart = "/etc/rc.d/named start" # 这是bind的停止脚本 namedstop = "/etc/rc.d/named stop" # 这是bind的重启脚本 namedrestart = "/etc/rc.d/named restart" if (system == 'Darwin'):
def print_current_platform(): (system, node, release, version, machine, processor) = uname() bits = architecture()[0] alias = "%s %s %s" % system_alias(system, release, version) python = "%s %s" % (python_implementation(), python_version()) print "Using %s (%s) on %s, %s" % (python, bits, alias, machine)