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