def main(): # ОС, Платформа print('_ОС, Платформа_', end=' : ') print(platform.platform(aliased=0, terse=0), end=' ') print(platform.win32_edition()) # CPU print('_CPU_', end=' : ') print(platform.processor())
def get_system_info() -> OrderedDict: """ Get system info as an ordered dictionary. """ output: OrderedDict = OrderedDict() _dict_append(output, "System", lambda: platform.system()) if output["System"] == "Windows": _dict_append(output, "Win32 version", lambda: platform.win32_ver()) if hasattr(platform, "win32_edition"): _dict_append(output, "Win32 edition", lambda: platform.win32_edition()) # type:ignore[attr-defined] elif output["System"] == "Darwin": _dict_append(output, "Mac version", lambda: platform.mac_ver()[0]) else: linux_ver = re.search(r'PRETTY_NAME="(.*)"', open("/etc/os-release", "r").read()) if linux_ver: _dict_append(output, "Linux version", lambda: linux_ver.group(1)) _dict_append(output, "Platform", lambda: platform.platform()) _dict_append(output, "Processor", lambda: platform.processor()) _dict_append(output, "Machine", lambda: platform.machine()) _dict_append(output, "Python version", lambda: platform.python_version()) if not has_psutil: _dict_append(output, "`psutil` missing", lambda: "run `pip install monai[psutil]`") else: p = psutil.Process() with p.oneshot(): _dict_append(output, "Process name", lambda: p.name()) _dict_append(output, "Command", lambda: p.cmdline()) _dict_append(output, "Open files", lambda: p.open_files()) _dict_append(output, "Num physical CPUs", lambda: psutil.cpu_count(logical=False)) _dict_append(output, "Num logical CPUs", lambda: psutil.cpu_count(logical=True)) _dict_append(output, "Num usable CPUs", lambda: len(psutil.Process().cpu_affinity())) _dict_append(output, "CPU usage (%)", lambda: psutil.cpu_percent(percpu=True)) _dict_append(output, "CPU freq. (MHz)", lambda: round(psutil.cpu_freq(percpu=False)[0])) _dict_append( output, "Load avg. in last 1, 5, 15 mins (%)", lambda: [round(x / psutil.cpu_count() * 100, 1) for x in psutil.getloadavg()], ) _dict_append(output, "Disk usage (%)", lambda: psutil.disk_usage(os.getcwd()).percent) _dict_append( output, "Avg. sensor temp. (Celsius)", lambda: round( np.mean([item.current for sublist in psutil.sensors_temperatures().values() for item in sublist], 1) ), ) mem = psutil.virtual_memory() _dict_append(output, "Total physical memory (GB)", lambda: round(mem.total / 1024 ** 3, 1)) _dict_append(output, "Available memory (GB)", lambda: round(mem.available / 1024 ** 3, 1)) _dict_append(output, "Used memory (GB)", lambda: round(mem.used / 1024 ** 3, 1)) return output
def about_operating_system(): """Show information about the operating system""" if parameters["Operating System"]: print("[Operating system]") print("os.name={}".format(os.name)) print("platform.system()={}".format(platform.system())) print("platform.release()={}".format(platform.release())) print("sys.platform={}".format(sys.platform)) print("sysconfig.get_platform()={}".format(sysconfig.get_platform())) print("platform.platform()={}".format(platform.platform())) print("platform.version()={}".format(platform.version())) print("platform.uname()={}".format(platform.uname())) if sys_type() == "Unix": print("os.uname().sysname={}".format(os.uname().sysname)) print("os.uname().release={}".format(os.uname().release)) print("os.uname().version={}".format(os.uname().version)) elif sys_type() == "Windows": print("sys.getwindowsversion()={}".format(sys.getwindowsversion())) print("platform.win32_ver()={}".format(platform.win32_ver())) print("platform.win32_edition()={}".format( platform.win32_edition())) print("platform.win32_is_iot()={}".format(platform.win32_is_iot())) print() if sys_type() == "Unix": print("[Operating system/Configuration]") for name in os.confstr_names: try: print("os.confstr('{}')={}".format(name, os.confstr(name))) except OSError as error: print("os.confstr('{}')={}".format(name, "Error: " + str(error))) for name in os.sysconf_names: try: print("os.sysconf('{}')={}".format(name, os.sysconf(name))) except OSError as error: print("os.sysconf('{}')={}".format(name, "Error: " + str(error))) print() print("[Operating system/Portability]") print("os.curdir={}".format(os.curdir)) print("os.pardir={}".format(os.pardir)) print("os.sep={}".format(os.sep)) print("os.altsep={}".format(os.altsep)) print("os.extsep={}".format(os.extsep)) print("os.pathsep={}".format(os.pathsep)) print("os.defpath={}".format(os.defpath)) print("os.devnull={}".format(os.devnull)) print("os.linesep={}".format(os.linesep))
class Win32MimeTypesTestCase(unittest.TestCase): def setUp(self): # ensure all entries actually come from the Windows registry self.original_types_map = mimetypes.types_map.copy() mimetypes.types_map.clear() mimetypes.init() self.db = mimetypes.MimeTypes() def tearDown(self): # restore default settings mimetypes.types_map.clear() mimetypes.types_map.update(self.original_types_map) @unittest.skipIf(win32_edition() in ('NanoServer', 'WindowsCoreHeadless', 'IoTEdgeOS'), "MIME types registry keys unavailable") def test_registry_parsing(self): # the original, minimum contents of the MIME database in the # Windows registry is undocumented AFAIK. # Use file types that should *always* exist: eq = self.assertEqual eq(self.db.guess_type("foo.txt"), ("text/plain", None)) eq(self.db.guess_type("image.jpg"), ("image/jpeg", None)) eq(self.db.guess_type("image.png"), ("image/png", None))
class Win32MimeTypesTestCase(unittest.TestCase): def setUp(self): # ensure all entries actually come from the Windows registry self.original_types_map = mimetypes.types_map.copy() mimetypes.types_map.clear() mimetypes.init() self.db = mimetypes.MimeTypes() def tearDown(self): # restore default settings mimetypes.types_map.clear() mimetypes.types_map.update(self.original_types_map) @unittest.skipIf(win32_edition() in ('NanoServer', 'WindowsCoreHeadless', 'IoTEdgeOS'), "MIME types registry keys unavailable") def test_registry_parsing(self): # the original, minimum contents of the MIME database in the # Windows registry is undocumented AFAIK. # Use file types that should *always* exist: eq = self.assertEqual eq(self.db.guess_type("foo.txt"), ("text/plain", None)) eq(self.db.guess_type("image.jpg"), ("image/jpeg", None)) eq(self.db.guess_type("image.png"), ("image/png", None)) @unittest.skipIf(not hasattr(_winapi, "_mimetypes_read_windows_registry"), "read_windows_registry accelerator unavailable") def test_registry_accelerator(self): from_accel = {} from_reg = {} _winapi._mimetypes_read_windows_registry( lambda v, k: from_accel.setdefault(k, set()).add(v)) mimetypes.MimeTypes._read_windows_registry( lambda v, k: from_reg.setdefault(k, set()).add(v)) self.assertEqual(list(from_reg), list(from_accel)) for k in from_reg: self.assertEqual(from_reg[k], from_accel[k])
class Win64WinregTests(BaseWinregTests): def test_named_arguments(self): self._test_named_args(HKEY_CURRENT_USER, test_key_name) # Clean up and also exercise the named arguments DeleteKeyEx(key=HKEY_CURRENT_USER, sub_key=test_key_name, access=KEY_ALL_ACCESS, reserved=0) @unittest.skipIf(win32_edition() in ('WindowsCoreHeadless', 'IoTEdgeOS'), "APIs not available on WindowsCoreHeadless") def test_reflection_functions(self): # Test that we can call the query, enable, and disable functions # on a key which isn't on the reflection list with no consequences. with OpenKey(HKEY_LOCAL_MACHINE, "Software") as key: # HKLM\Software is redirected but not reflected in all OSes self.assertTrue(QueryReflectionKey(key)) self.assertIsNone(EnableReflectionKey(key)) self.assertIsNone(DisableReflectionKey(key)) self.assertTrue(QueryReflectionKey(key)) @unittest.skipUnless(HAS_REFLECTION, "OS doesn't support reflection") def test_reflection(self): # Test that we can create, open, and delete keys in the 32-bit # area. Because we are doing this in a key which gets reflected, # test the differences of 32 and 64-bit keys before and after the # reflection occurs (ie. when the created key is closed). try: with CreateKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0, KEY_ALL_ACCESS | KEY_WOW64_32KEY) as created_key: self.assertNotEqual(created_key.handle, 0) # The key should now be available in the 32-bit area with OpenKey(HKEY_CURRENT_USER, test_reflect_key_name, 0, KEY_ALL_ACCESS | KEY_WOW64_32KEY) as key: self.assertNotEqual(key.handle, 0) # Write a value to what currently is only in the 32-bit area SetValueEx(created_key, "", 0, REG_SZ, "32KEY") # The key is not reflected until created_key is closed. # The 64-bit version of the key should not be available yet. open_fail = lambda: OpenKey( HKEY_CURRENT_USER, test_reflect_key_name, 0, KEY_READ | KEY_WOW64_64KEY) self.assertRaises(OSError, open_fail) # Now explicitly open the 64-bit version of the key with OpenKey(HKEY_CURRENT_USER, test_reflect_key_name, 0, KEY_ALL_ACCESS | KEY_WOW64_64KEY) as key: self.assertNotEqual(key.handle, 0) # Make sure the original value we set is there self.assertEqual("32KEY", QueryValue(key, "")) # Set a new value, which will get reflected to 32-bit SetValueEx(key, "", 0, REG_SZ, "64KEY") # Reflection uses a "last-writer wins policy, so the value we set # on the 64-bit key should be the same on 32-bit with OpenKey(HKEY_CURRENT_USER, test_reflect_key_name, 0, KEY_READ | KEY_WOW64_32KEY) as key: self.assertEqual("64KEY", QueryValue(key, "")) finally: DeleteKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, KEY_WOW64_32KEY, 0) @unittest.skipUnless(HAS_REFLECTION, "OS doesn't support reflection") def test_disable_reflection(self): # Make use of a key which gets redirected and reflected try: with CreateKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0, KEY_ALL_ACCESS | KEY_WOW64_32KEY) as created_key: # QueryReflectionKey returns whether or not the key is disabled disabled = QueryReflectionKey(created_key) self.assertEqual(type(disabled), bool) # HKCU\Software\Classes is reflected by default self.assertFalse(disabled) DisableReflectionKey(created_key) self.assertTrue(QueryReflectionKey(created_key)) # The key is now closed and would normally be reflected to the # 64-bit area, but let's make sure that didn't happen. open_fail = lambda: OpenKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0, KEY_READ | KEY_WOW64_64KEY) self.assertRaises(OSError, open_fail) # Make sure the 32-bit key is actually there with OpenKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0, KEY_READ | KEY_WOW64_32KEY) as key: self.assertNotEqual(key.handle, 0) finally: DeleteKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, KEY_WOW64_32KEY, 0) def test_exception_numbers(self): with self.assertRaises(FileNotFoundError) as ctx: QueryValue(HKEY_CLASSES_ROOT, 'some_value_that_does_not_exist')
def win_edition(): print(platform.win32_edition())
import platform from time import sleep analisador = int( input("Informe '[1] + ENTER' para analizar ou '[0] + ENTER' para sair:")) a0 = platform._node() b0 = platform.machine() c0 = platform.processor() d0 = platform.system() d1 = platform.version() d2 = platform.release() d3 = platform.win32_edition() e0 = platform.architecture() if analisador == 1: print("-" * 106) print(f'Este é o computador \033[7;30m{a0}\33[m.') print("-" * 106) sleep(1) print("-" * 106) print( f'O \033[7;30m{a0}\33[m é uma máquina........................... \033[7;30m{b0}\33[m\33[m.' ) sleep(1) print("-" * 106) print( f'O \033[7;30m{a0}\33[m tem um processador...................... \033[7;30m{c0}\33[m.' ) sleep(1) print("-" * 106) print( f'O \033[7;30m{a0}\33[m esta utilizando o sistema operacional... \033[7;30m{d0} {d1} {d2} {d3}\33[m.' )
} } } if platform.system() == "Linux": VARIABLES["variables"]["linux"] = { "libc": platform.libc_ver()[0], "libc_version": platform.libc_ver()[1] } elif platform.system() == "Windows": VARIABLES["variables"]["windows"] = { "win32_release": platform.win32_ver()[0], "win32_ver": platform.win32_ver()[1], "win32_service_pack": platform.win32_ver()[2], "win32_os_type": platform.win32_ver()[3], "win32_edition": platform.win32_edition(), "win32_iot_edition": platform.win32_is_iot() } VARIABLES["constants"]["shell"]["ps_null"] = "$null" VARIABLES["constants"]["shell"]["cmd_null"] = "NUL" # On Windows alias to a reasonable default VARIABLES["constants"]["shell"]["dev_null"] = "$null" elif platform.system() == "Darwin": VARIABLES["variables"]["mac"] = { "mac_release": platform.mac_ver()[0], "mac_version": platform.mac_ver()[1][0], "mac_dev_stage": platform.mac_ver()[1][1], "mac_non_release_version": platform.mac_ver()[1][2], "mac_machine": platform.mac_ver()[2] }
def update_event(self, inp=-1): self.set_output_val(0, platform.win32_edition())
import platform import sys import os import psutil import re import uuid uname = platform.uname() architecture = platform.architecture() python_version = platform.python_version() system_architecture = "32 bits" if (sys.maxsize > 2**32): system_architecture = "64 bits" platformInfo = platform.platform().split("-") system_edition = platform.win32_edition() memory = str(round(psutil.virtual_memory().total / (1024.0**3))) + " GB" mac_address = ':'.join(re.findall('..', '%012x' % uuid.getnode())) print() print( f"System: {uname.system} {uname.release} {system_edition} {platformInfo[3]} {system_architecture} " ) print(f"Version: {uname.version} ") print(f"Node name: {uname.node} ") print(f"Machine: {uname.machine} ") print(f"Processor: {uname.processor} ") print(f"Memory: {memory}") print() print(f"MAC Address: {mac_address}") print() print(f"Login: {os.getlogin()}")
def task_hardware_config(): cpu_count = multiprocessing.cpu_count() os_version = platform.win32_edition()+platform.version() ram_size = round(psutil.virtual_memory().total/1024/1024/1024) hardware = f"CPU{cpu_count} RAM{ram_size}GB"
def DetectOS(): """Функция обнаружения операционной системы""" SlovarOS = { 'Windows XP ProfessionalEdition': '3 870 руб', 'Windows XP HomeEdition': '1 480 руб', 'Windows XP 64-bitEdition': '4 140 руб', 'Windows XP Профессиональная': '3 870 руб', 'Windows XP Домашняя': '1 480 руб', 'Windows XP TabletPCEdition': '1 278 руб', 'Windows XP Professionalx64Edition': '4 140 руб', 'Windows XP Embedded': 'от 4 000 руб', 'Windows EmbeddedPOSReady': 'от 4 000 руб', 'Windows XP StarterEdition': '1 250 руб', 'Windows FundamentalsforLegacyPCs': 'от 4 000 руб', 'Windows Server 2003 WebEdition': '4 500 руб', 'Windows XPEditionN': '3 455 руб', 'Windows Server 2003 StandardEdition': '4 500 руб', 'Windows Server 2003 EnterpriseEdition': '4 500 руб', 'Windows Server 2003 DatacenterEdition': '4 500 руб', 'Windows Vista Starter': '990 руб', 'Windows Vista HomeBasic': '1 990 руб', 'Windows Vista Домашняя базовая': '1 990 руб', 'Windows Vista HomePremium': '2 430 руб', 'Windows Vista Домашняя расширенная': '2 430 руб', 'Windows Vista Business': '1 990 руб', 'Windows Vista Бизнес': '1 990 руб', 'Windows Vista Начальная': '990 руб', 'Windows Vista Enterprise': '1 990 руб', 'Windows Vista Корпоративная': '1 990 руб', 'Windows Vista Максимальная': '3 990 руб', 'Windows Vista UltimateUpgradeLimitedNumberedSignatureEdition': '9 339 руб', 'Windows Home Server': '6 803 руб', 'Windows Server 2008 StandardEdition': '22 500 руб', 'Windows Server 2008 EnterpriseEdition': '114 495 руб', 'Windows WebServer2008': '44 950 руб', 'Windows Server 2008 DatacenterEdition': '20 818 руб', 'Windows HPCServer2008': 'от 20 818 руб', 'Windows Storage Server2008': 'от 20 818 руб', 'Windows SmallBusinessServer2008': '35624 руб', 'Windows Essential BusinessServer2008': '156 581 руб', 'Windows 7 Ultimate': '8 090 руб', 'Windows 7 Максимальная': '8 090 руб', 'Windows 7 Домашняя расширенная': '6 850 руб', 'Windows 7 Enterprise': '13 167 руб', 'Windows 7 Корпоративная': '13 167 руб', 'Windows 7 Professional': '9 050 руб', 'Windows 7 Профессиональная': '9 050 руб', 'Windows 7 HomePremium': '6 850 руб', 'Windows 7 HomeBasic': '5 570 руб', 'Windows 7 Домашняя базовая': '5 570 руб', 'Windows 7 Starter': '4 390 руб', 'Windows 7 Начальная': '4 390 руб', 'Windows Server 2008 R2 Standard': '50 452 руб', 'Windows Server 2008 R2 Enterprise': '128 000 руб', 'Windows Server 2012 Standard': '62 908 руб', 'Windows Server 2008 R2 Foundation': '50 452 руб', 'Windows Home Server 2011': '12 760 руб', 'Windows 8 Professional': '5 480 руб', 'Windows 8 Профессиональная': '5 480 руб', 'Windows 8 Pro': '5 480 руб', 'Windows 8 Корпоративная': '5 480 руб', 'Windows 8 Enterprise': '5 480 руб', 'Windows 8 Core': '5 480 руб', 'Windows Server 2012 Foundation': '16 270 руб', 'Windows Server 2012 Essentials': '28 502 руб', 'Windows Server 2012 Datacenter': '280 392 руб', 'Windows RT 8.1': '5 480 руб', 'Windows 8.1 Pro': '5 480 руб', 'Windows 8.1 Профессиональная': '5 480 руб', 'Windows 10 HomeWithBing': '8 699 руб', 'Windows 8.1 Корпоративная': '5 480 руб', 'Windows 8.1 Enterprise': '5 480 руб', 'Windows 10 Домашняя': '8 699 руб', 'Windows 10 Home': '8 699 руб', 'Windows 10 Профессиональная': '12 599 руб', 'Windows 10 Pro': '12 599 руб', 'Windows 10 Корпоративная': '8 935 руб', 'Windows 10 Enterprise': '8 935 руб', 'Windows 10 Домашняя для одного языка': '8 699 руб', 'Windows 10 HomeSingleLanguage': '8 699 руб', 'Windows 10 HomeSL': '8 699 руб', 'Windows RT': '5 480 руб', 'Windows Vista Ultimate': '3 990 руб', 'Windows 10 CoreSingleLanguage': '7 499 руб', 'Windows 10 Домашняя с Bing': '8 699 руб', 'Windows 10 S': '7 750 руб', 'Windows 10 Pro для образовательных учреждений': '12 599 руб', 'Windows 10 ProEducation': '12 599 руб', 'Windows 8.1 Professional': '5 480 руб', 'Windows 10 Pro Для рабочих станций': '12 599 руб', 'Windows 10 ProforWorkstations': '12 599 руб', 'Windows 10 Корпоративная с долгосрочным обслуживанием': '16 460 руб', 'Windows 10 EnterpriseLTSC': '16 460 руб', 'Windows 10 EnterpriseLTSB': '16 460 руб', 'Windows 10 для образовательных учреждений': '8 699 руб', 'Windows 10 Education': '8 699 руб', 'Windows 7': 'от 4 000 руб', 'Windows Vista': 'от 2 000 руб', 'Windows 10 Team': 'от 7 000 руб', 'Windows 10 HomeSLN': '8 699 руб', 'Windows 10 HomeN': '8 699 руб', 'Windows 10 SN': 'от 7 000 руб', 'Windows 10 ProN': '12 599 руб', 'Windows 10 EntepriseN': '8 935 руб', 'Windows 10 EnterpiseLTSCN': '16 460 руб', 'Windows 10 HomeSLKN': '8 699 руб', 'Windows 10 HomeKN': '8 699 руб', 'Windows 10 SKN': 'от 7 000 руб', 'Windows 10 ProKN': '', 'Windows 10 EntepriseKN': '8 935 руб', 'Windows 10 Enterpise LTSCKN': '16 460 руб', 'Windows 10 Entry': 'от 7 000 руб', 'Windows 10 Value': 'от 7 000 руб', 'Windows 10 Core': '8 699 руб', 'Windows 10 Core +': '8 699 руб', 'Windows 10 Core+': '8 699 руб', 'Windows 10 Advanced': 'от 7 000 руб', 'Windows 10 IoTCore': 'от 7 000 руб', 'Windows 10 IoTMobile': 'от 7 000 руб', 'Windows 10 IoTEnterprise': 'от 7 000 руб', 'Windows 10 IoTMobileEnterprise': 'от 7 000 руб', 'Windows 10 Мобильная корпоративная': 'от 7 000 руб', 'Windows 8.1 Core': '5 480 руб', 'Windows 8.1 с Bing': '5 480 руб', 'Windows 8.1 для одного языка': '5 480 руб', 'Windows 8.1': '5 480 руб', 'Windows 8': '5 480 руб', 'Windows 10': 'от 7 000 руб', 'Windows 10 Мобильная': 'от 7 000 руб', } sys_rel_ed = platform.system() + ' ' + platform.release( ) + ' ' + platform.win32_edition() sys_ed = platform.system() + ' ' + platform.win32_edition() sys_rel = platform.system() + ' ' + platform.release() s = '' matchOS = False for itemOS in SlovarOS: s = SlovarOS[itemOS] if sys_rel_ed == itemOS: matchOS = True return itemOS, s elif sys_ed == itemOS: matchOS = True return sys_ed, s elif sys_rel == itemOS: matchOS = True return sys_rel, s else: s = '???' if matchOS == False: return sys_rel_ed, s
if getlang == "ru": from strings import langRU as lang else: from strings import langEN as lang #Welcome message print(":===================FixAct 1.1===================:") print(lang.welcome) print(lang.mainSelect) select = input(lang.InputSelect) #Variables sysVer = platform.version() sysNum = platform.win32_ver()[0] sysEdition = platform.win32_edition() sysName = sysNum + sysEdition #=============================== def StartOfficeAct(): srv = KMSdata.kmsServer #Getting path to ProgramFiles folder progFilesFolder = os.environ["PROGRAMFILES"] #Office paths office10 = progFilesFolder+r"\Microsoft Office\Office14\ospp.vbs" office13 = progFilesFolder+r"\Microsoft Office\Office15\ospp.vbs" office = progFilesFolder+r"\Microsoft Office\Office16\ospp.vbs" if os.path.exists(office10): try:
############################################################################### # Windows Platform information ############################################################################### # win32_ver() # * Get additional version information from the Windows Registry and return a # tuple (release, version, csd, ptype) referring to OS release, version # number, CSD level (service pack) and OS type (multi/single processor) print(platform.win32_ver()) # ('10', '10.0.19041', 'SP0', 'Multiprocessor Free') # win32_edition() # * Returns a string representing the current Windows edition print(platform.win32_edition()) # Enterprise # win32_is_iot() # * Return True if the Windows edition returned by win32_edition() is # recognized as an IoT edition print(platform.win32_is_iot()) # False ############################################################################### # Mac Platform information ###############################################################################
def system(): print("systemInfo 0.4") print("Host Name: " + platform.node()) print("OS: " + platform.system() + " " + platform.release() + " " + platform.win32_edition()) print("IP: " + socket.gethostbyname(socket.gethostname()))