pyhw 0.7.3__py3-none-any.whl → 0.8.0__py3-none-any.whl

pyhw/__init__.py

@@ -1 +1 @@
-__version__ = '0.7.3'
+__version__ = '0.8.0'

pyhw/__main__.py

@@ -17,8 +17,8 @@ from .pyhwUtil import getOS, selectOSLogo
 
 def main():
     current_os = getOS()
-    if current_os not in ["linux", "macos", "freebsd"]:
-        print(f"Only Linux, macOS, and FreeBSD is supported for now. Current os: {current_os}")
+    if current_os not in ["linux", "macos", "freebsd", "windows"]:
+        print(f"Only Linux, macOS, FreeBSD and Windows are supported for now. Current OS: {current_os}")
         return
     data = Data()
     data.title = TitleDetect(os=current_os).getTitle().title

pyhw/backend/cpu/cpuBase.py

@@ -1,6 +1,3 @@
-from .linux import CPUDetectLinux
-from .macos import CPUDetectMacOS
-from .bsd import CPUDetectBSD
 from ...pyhwException import OSUnsupportedException
 
 
@@ -10,10 +7,16 @@ class CPUDetect:
 
     def getCPUInfo(self):
         if self.OS == "linux":
+            from .linux import CPUDetectLinux
             return CPUDetectLinux().getCPUInfo()
         elif self.OS == "macos":
+            from .macos import CPUDetectMacOS
             return CPUDetectMacOS().getCPUInfo()
         elif self.OS == "freebsd":
+            from .bsd import CPUDetectBSD
             return CPUDetectBSD().getCPUInfo()
+        elif self.OS == "windows":
+            from .windows import CPUDetectWindows
+            return CPUDetectWindows().getCPUInfo()
         else:
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/cpu/windows.py

@@ -0,0 +1,48 @@
+import re
+import os
+import subprocess
+from .cpuInfo import CPUInfo
+import json
+
+
+class CPUDetectWindows:
+    def __init__(self):
+        self.__cpuInfo = CPUInfo()
+
+    def getCPUInfo(self):
+        self.__getCPUInfo()
+        self.__modelClean()
+        if self.__cpuInfo.model == "":
+            self.__cpuInfo.model = "Unknown"
+        if self.__cpuInfo.model != "":
+            self.__cpuInfo.cpu = self.__cpuInfo.model
+            if self.__cpuInfo.cores != "":
+                self.__cpuInfo.cpu += f" ({self.__cpuInfo.cores})"
+            if self.__cpuInfo.frequency != "":
+                self.__cpuInfo.cpu += f" @ {self.__cpuInfo.frequency}"
+        return self.__cpuInfo
+
+    def __getCPUInfo(self):
+        COMMAND = "Get-CimInstance -ClassName Win32_Processor | Select-Object Name,NumberOfLogicalProcessors,MaxClockSpeed | ConvertTo-JSON"
+
+        try:
+            result = subprocess.run(["powershell", "-NoProfile", "-Command", COMMAND], capture_output=True, text=True)
+        except subprocess.SubprocessError:
+            exit(-1)
+
+        res = json.loads(result.stdout)
+        name = res["Name"]
+        cores = res["NumberOfLogicalProcessors"]
+        frequency = round(int(res["MaxClockSpeed"]) / 1000.0, 2)  # GHz
+        if "@" in name:
+            self.__cpuInfo.model = name.split("@")[0].strip()
+        else:
+            self.__cpuInfo.model = name
+        self.__cpuInfo.cores = str(cores)
+        self.__cpuInfo.frequency = f"{frequency:.2f} GHz"
+
+    def __modelClean(self):
+        self.__cpuInfo.model = self.__cpuInfo.model.replace("(R)", "")
+        self.__cpuInfo.model = self.__cpuInfo.model.replace("(TM)", "")
+        self.__cpuInfo.model = self.__cpuInfo.model.replace("CPU ", "")
+

pyhw/backend/gpu/gpuBase.py

@@ -1,6 +1,4 @@
-from .linux import GPUDetectLinux
-from .macos import GPUDetectMacOS
-from .bsd import GPUDetectBSD
+from ...pyhwException import OSUnsupportedException
 
 
 class GPUDetect:
@@ -9,10 +7,16 @@ class GPUDetect:
 
     def getGPUInfo(self):
         if self.OS == "linux":
+            from .linux import GPUDetectLinux
             return GPUDetectLinux().getGPUInfo()
         elif self.OS == "macos":
+            from .macos import GPUDetectMacOS
             return GPUDetectMacOS().getGPUInfo()
         elif self.OS == "freebsd":
+            from .bsd import GPUDetectBSD
             return GPUDetectBSD().getGPUInfo()
+        elif self.OS == "windows":
+            from .windows import GPUDetectWindows
+            return GPUDetectWindows().getGPUInfo()
         else:
-            raise NotImplementedError("Unsupported operating system")
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/gpu/windows.py

@@ -0,0 +1,41 @@
+import subprocess
+from .gpuInfo import GPUInfo
+from ..cpu import CPUDetect
+from ...pyhwUtil import getArch
+import pypci
+
+
+class GPUDetectWindows:
+    def __init__(self):
+        self.__gpuInfo = GPUInfo()
+
+    def getGPUInfo(self):
+        self.__getGPUInfo()
+        self.__sortGPUList()
+        return self.__gpuInfo
+
+    def __getGPUInfo(self):
+        gpu_devices = pypci.PCI().FindAllVGA()
+        if len(gpu_devices) == 0:
+            self.__handleNonePciDevices()
+        else:
+            for device in gpu_devices:
+                if device.subsystem_device_name != "":
+                    device_name = f"{device.vendor_name} {device.device_name} ({device.subsystem_device_name})"
+                else:
+                    device_name = f"{device.vendor_name} {device.device_name}"
+                self.__gpuInfo.gpus.append(self.__gpuNameClean(device_name))
+                self.__gpuInfo.number += 1
+
+    def __handleNonePciDevices(self):
+        self.__gpuInfo.gpus.append("Not found")
+        self.__gpuInfo.number = 1
+
+    @staticmethod
+    def __gpuNameClean(gpu_name: str):
+        gpu_name_clean = gpu_name.replace("Corporation ", "")
+        return gpu_name_clean
+
+    def __sortGPUList(self):
+        self.__gpuInfo.gpus.sort()
+

pyhw/backend/host/hostBase.py

@@ -1,7 +1,3 @@
-from .linux import HostDetectLinux
-from .macos import HostDetectMacOS
-from .windows import HostDetectWindows
-from .bsd import HostDetectBSD
 from ...pyhwException import OSUnsupportedException
 
 
@@ -11,12 +7,16 @@ class HostDetect:
 
     def getHostInfo(self):
         if self.OS == "linux":
+            from .linux import HostDetectLinux
             return HostDetectLinux().getHostInfo()
         elif self.OS == "macos":
+            from .macos import HostDetectMacOS
             return HostDetectMacOS().getHostInfo()
         elif self.OS == "freebsd":
+            from .bsd import HostDetectBSD
             return HostDetectBSD().getHostInfo()
         elif self.OS == "windows":
-            pass
+            from .windows import HostDetectWindows
+            return HostDetectWindows().getHostInfo()
         else:
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/host/hostInfo.py

@@ -3,11 +3,20 @@ from dataclasses import dataclass
 
 @dataclass
 class HostInfo:
-    model = ""
-    family = ""
-    name = ""
-    version = ""
-    sku = ""
-    serial = ""
-    uuid = ""
-    vendor = ""
+    """
+    HostInfo class to store host information.
+    """
+    def __init__(self):
+        """
+        Initialize HostInfo class, model attribute is required.
+        """
+        self.os = ""
+        self.model = ""
+        self.family = ""
+        self.name = ""
+        self.version = ""
+        self.sku = ""
+        self.serial = ""
+        self.uuid = ""
+        self.vendor = ""
+

pyhw/backend/host/windows.py

@@ -1,5 +1,36 @@
 """
     In dev.
 """
+from ...pyhwUtil import getArch
+from ...pyhwException import BackendException
+from .hostInfo import HostInfo
+import winreg
+
+
 class HostDetectWindows:
-    pass
+    def __init__(self):
+        self._hostInfo = HostInfo()
+        self._arch = getArch()
+
+    def getHostInfo(self):
+        self._getModel()
+        return self._hostInfo
+
+    def _getModel(self):
+        try:
+            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"HARDWARE\DESCRIPTION\System\BIOS")
+            manufacturer, _ = winreg.QueryValueEx(key, "SystemManufacturer")
+            name, _ = winreg.QueryValueEx(key, "SystemProductName")
+            version, _ = winreg.QueryValueEx(key, "SystemVersion")
+            winreg.CloseKey(key)
+        except FileNotFoundError:
+            raise BackendException("Unable to retrieve system information.")
+        self._hostInfo.name = name
+        self._hostInfo.version = version
+        self._hostInfo.vendor = manufacturer
+        self.__handleVM()
+        self._hostInfo.model = self._hostInfo.name + " " + self._hostInfo.version
+
+    def __handleVM(self):
+        if self._hostInfo.name.startswith("VMware"):
+            self._hostInfo.version = ""

pyhw/backend/kernel/kernelBase.py

@@ -1,4 +1,3 @@
-from .unix import KernelDetectUnix
 from ...pyhwException import OSUnsupportedException
 
 
@@ -8,8 +7,10 @@ class KernelDetect:
 
     def getKernelInfo(self):
         if self.OS in ["linux", "macos", "freebsd"]:
+            from .unix import KernelDetectUnix
             return KernelDetectUnix().getKernelInfo()
         elif self.OS == "windows":
-            raise OSUnsupportedException("Unsupported operating system")
+            from .windows import KernelDetectWindows
+            return KernelDetectWindows().getKernelInfo()
         else:
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/kernel/kernelInfo.py

@@ -3,7 +3,13 @@ from dataclasses import dataclass
 
 @dataclass
 class KernelInfo:
+    """
+    Data class for storing kernel information.
+    """
     def __init__(self):
+        """
+        Initialize the data class, kernel attribute is required.
+        """
         self.name = ""
         self.version = ""
         self.machine = ""

pyhw/backend/kernel/windows.py

@@ -1,7 +1,29 @@
 """
     In dev.
 """
+from .kernelInfo import KernelInfo
+from ...pyhwException import BackendException
+import platform
+import winreg
 
 
 class KernelDetectWindows:
-    pass
+    def __init__(self):
+        self.__kernelInfo = KernelInfo()
+
+    def getKernelInfo(self):
+        version = platform.version()
+        machine = platform.machine()
+        display = self.__get_windows_version()
+        self.__kernelInfo.kernel = f"{version} ({display}) {machine}"
+        return self.__kernelInfo
+
+    @staticmethod
+    def __get_windows_version():
+        try:
+            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows NT\CurrentVersion")
+            display_version, _ = winreg.QueryValueEx(key, "DisplayVersion")
+            winreg.CloseKey(key)
+            return str(display_version)
+        except:
+            raise BackendException("Unable to determine Windows kernel version.")

pyhw/backend/memory/memoryBase.py

@@ -1,6 +1,4 @@
-from .linux import MemoryDetectLinux
-from .macos import MemoryDetectMacOS
-from .bsd import MemoryDetectBSD
+from ...pyhwException import OSUnsupportedException
 
 
 class MemoryDetect:
@@ -9,10 +7,16 @@ class MemoryDetect:
 
     def getMemoryInfo(self):
         if self.OS == "linux":
+            from .linux import MemoryDetectLinux
             return MemoryDetectLinux().getMemoryInfo()
         elif self.OS == "macos":
+            from .macos import MemoryDetectMacOS
             return MemoryDetectMacOS().getMemoryInfo()
         elif self.OS == "freebsd":
+            from .bsd import MemoryDetectBSD
             return MemoryDetectBSD().getMemoryInfo()
+        elif self.OS == "windows":
+            from .windows import MemoryDetectWindows
+            return MemoryDetectWindows().getMemoryInfo()
         else:
-            raise NotImplementedError("Unsupported operating system")
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/memory/windows.py

@@ -0,0 +1,36 @@
+from ...pyhwException import BackendException
+from .memoryInfo import MemoryInfo
+import subprocess
+import json
+
+
+class MemoryDetectWindows:
+    def __init__(self):
+        self._memoryInfo = MemoryInfo()
+
+    def getMemoryInfo(self):
+        self._getMemory()
+        self._memoryInfo.memory = f"{self._memoryInfo.used} MiB / {self._memoryInfo.total} MiB"
+        return self._memoryInfo
+
+    def _getMemory(self):
+        COMMAND = 'Get-CimInstance -ClassName Win32_OperatingSystem | Select-Object FreePhysicalMemory,TotalVisibleMemorySize | ConvertTo-JSON'
+        try:
+            result = subprocess.run(["powershell", "-NoProfile", "-Command", COMMAND], capture_output=True, text=True)
+        except subprocess.SubprocessError:
+            raise BackendException("Failed to get memory information on Windows.")
+
+        res = json.loads(result.stdout)
+        free_memory = int(res['FreePhysicalMemory']) / 1024
+        total_memory = int(res['TotalVisibleMemorySize']) / 1024
+        used_memory = total_memory - free_memory
+        self._memoryInfo.total = round(total_memory, 2)
+        self._memoryInfo.available = round(free_memory, 2)
+        self._memoryInfo.used = round(used_memory, 2)
+
+
+
+
+
+
+

pyhw/backend/nic/linux.py

@@ -3,6 +3,7 @@ from .nicInfo import NICInfo
 from ...pyhwUtil import getArch
 from ...pyhwException import BackendException
 import pypci
+import os
 
 
 class NICDetectLinux:
@@ -28,9 +29,25 @@ class NICDetectLinux:
                 self._nicInfo.number += 1
 
     def __handleNonePciDevices(self):
-        # placeholder for a more advanced method.
-        self._nicInfo.nics.append("Not found")
-        self._nicInfo.number = 1
+        # need to update
+        interfaces = list()
+        for i in os.listdir('/sys/class/net/'):
+            if i == "lo":
+                continue
+            interfaces.append(i)
+        if len(interfaces) > 0:
+            for interface in interfaces:
+                try:
+                    if_ip = subprocess.run(["bash", "-c", f"ip -4 addr show {interface} | grep inet | awk '{{print $2}}'"], capture_output=True, text=True).stdout.strip().split("/")[0]
+                    self._nicInfo.nics.append(f"{interface} @ {if_ip}")
+                    self._nicInfo.number += 1
+                except:
+                    pass
+        else:
+            pass
+        if self._nicInfo.number == 0:
+            self._nicInfo.nics.append("Not found")
+            self._nicInfo.number = 1
 
     @staticmethod
     def _nicNameClean(nic_name: str):

pyhw/backend/nic/nicBase.py

@@ -1,6 +1,4 @@
-from .linux import NICDetectLinux
-from .macos import NICDetectMacOS
-from .bsd import NICDetectBSD
+from ...pyhwException import OSUnsupportedException
 
 
 class NICDetect:
@@ -16,10 +14,16 @@ class NICDetect:
         :return: dataclass NICInfo, direct attr: nics
         """
         if self.OS == "linux":
+            from .linux import NICDetectLinux
             return NICDetectLinux().getNICInfo()
         elif self.OS == "macos":
+            from .macos import NICDetectMacOS
             return NICDetectMacOS().getNICInfo()
         elif self.OS == "freebsd":
+            from .bsd import NICDetectBSD
             return NICDetectBSD().getNICInfo()
+        elif self.OS == "windows":
+            from .windows import NICDetectWindows
+            return NICDetectWindows().getNICInfo()
         else:
-            raise NotImplementedError("Unsupported operating system")
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/nic/windows.py

@@ -0,0 +1,44 @@
+import subprocess
+from .nicInfo import NICInfo
+from ...pyhwUtil import getArch
+from ...pyhwException import BackendException
+import pypci
+import os
+
+
+class NICDetectWindows:
+    def __init__(self):
+        self._nicInfo = NICInfo()
+
+    def getNICInfo(self):
+        self._getNICInfo()
+        self._sortNICList()
+        return self._nicInfo
+
+    def _getNICInfo(self):
+        nic_devices = pypci.PCI().FindAllNIC()
+        if len(nic_devices) == 0:
+            self.__handleNonePciDevices()
+        else:
+            for device in nic_devices:
+                if device.subsystem_device_name != "":
+                    device_name = f"{device.vendor_name} {device.device_name} ({device.subsystem_device_name})"
+                else:
+                    device_name = f"{device.vendor_name} {device.device_name}"
+                self._nicInfo.nics.append(self._nicNameClean(device_name))
+                self._nicInfo.number += 1
+
+    def __handleNonePciDevices(self):
+        # need to update
+        self._nicInfo.nics.append("Not found")
+        self._nicInfo.number = 1
+
+    @staticmethod
+    def _nicNameClean(nic_name: str):
+        nic_name_clean = nic_name.replace("Corporation ", "")
+        return nic_name_clean
+
+    def _sortNICList(self):
+        return self._nicInfo.nics.sort()
+
+

pyhw/backend/npu/npuBase.py

@@ -1,6 +1,4 @@
-from .linux import NPUDetectLinux
-from .macos import NPUDetectMacOS
-from .bsd import NPUDetectBSD
+from ...pyhwException import OSUnsupportedException
 
 
 class NPUDetect:
@@ -9,12 +7,16 @@ class NPUDetect:
 
     def getNPUInfo(self):
         if self.OS == "linux":
+            from .linux import NPUDetectLinux
             return NPUDetectLinux().getNPUInfo()
         elif self.OS == "macos":
+            from .macos import NPUDetectMacOS
             return NPUDetectMacOS().getNPUInfo()
         elif self.OS == "freebsd":
+            from .bsd import NPUDetectBSD
             return NPUDetectBSD().getNPUInfo()
+        elif self.OS == "windows":
+            from .windows import NPUDetectWindows
+            return NPUDetectWindows().getNPUInfo()
         else:
-            raise NotImplementedError("Unsupported operating system")
-
-
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/npu/windows.py

@@ -0,0 +1,40 @@
+from .npuInfo import NPUInfo
+import pypci
+
+
+class NPUDetectWindows:
+    def __init__(self):
+        self._npuInfo = NPUInfo()
+
+    def getNPUInfo(self):
+        self._getNPUInfo()
+        self._sortNPUList()
+        return self._npuInfo
+
+    def _getNPUInfo(self):
+        npu_devices = pypci.PCI().FindAllNPU()
+        if len(npu_devices) == 0:
+            self._handleNonePciDevices()
+        else:
+            for device in npu_devices:
+                if device.subsystem_device_name != "":
+                    device_name = f"{device.vendor_name} {device.device_name} ({device.subsystem_device_name})"
+                else:
+                    device_name = f"{device.vendor_name} {device.device_name}"
+                self._npuInfo.npus.append(self._npuNameClean(device_name))
+                self._npuInfo.number += 1
+
+    def _handleNonePciDevices(self):
+        # Place Holder for unknown NPU
+        self._npuInfo.number = 1
+        self._npuInfo.npus.append("Not found")
+
+    @staticmethod
+    def _npuNameClean(npu_name: str):
+        npu_name_clean = npu_name.replace("Corporation ", "")
+        return npu_name_clean
+
+    def _sortNPUList(self):
+        self._npuInfo.npus.sort()
+
+

pyhw/backend/os/osBase.py

@@ -1,6 +1,3 @@
-from .linux import OSDetectLinux
-from .macos import OSDetectMacOS
-from .bsd import OSDetectBSD
 from ...pyhwException import OSUnsupportedException
 
 
@@ -10,10 +7,16 @@ class OSDetect:
 
     def getOSInfo(self):
         if self.__OS == "linux":
+            from .linux import OSDetectLinux
             return OSDetectLinux().getOSInfo()
         elif self.__OS == "macos":
+            from .macos import OSDetectMacOS
             return OSDetectMacOS().getOSInfo()
         elif self.__OS == "freebsd":
+            from .bsd import OSDetectBSD
             return OSDetectBSD().getOSInfo()
+        elif self.__OS == "windows":
+            from .windows import OSDetectWindows
+            return OSDetectWindows().getOSInfo()
         else:
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/os/osInfo.py

@@ -3,7 +3,13 @@ from dataclasses import dataclass
 
 @dataclass
 class OSInfo:
+    """
+    Dataclass to hold the OS information
+    """
     def __init__(self):
+        """
+        Initialize the dataclass, prettyName and id attributes are required.
+        """
         self.prettyName = ""
         self.name = ""
         self.id = ""

pyhw/backend/os/windows.py

@@ -0,0 +1,35 @@
+from .osInfo import OSInfo
+from ...pyhwException import BackendException
+import platform
+import winreg
+
+
+class OSDetectWindows:
+    def __init__(self):
+        self._osInfo = OSInfo()
+
+    def getOSInfo(self):
+        system = platform.system()
+        release = platform.release()
+        edition = platform.win32_edition()
+        machine = platform.machine()
+        display = self.__get_windows_version()
+        self._osInfo.prettyName = f"{system} {release} {display} ({edition}) {machine}"
+        if release == "10":
+            self._osInfo.id = "windows_10"
+        elif release == "11":
+            self._osInfo.id = "windows_11"
+        else:
+            self._osInfo.id = "windows_old"
+        return self._osInfo
+
+    @staticmethod
+    def __get_windows_version():
+        try:
+            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows NT\CurrentVersion")
+            display_version, _ = winreg.QueryValueEx(key, "DisplayVersion")
+            winreg.CloseKey(key)
+            return str(display_version)
+        except:
+            raise BackendException("Unable to determine Windows kernel version.")
+

pyhw/backend/shell/shellBase.py

@@ -1,4 +1,3 @@
-from .unix import ShellDetectUnix
 from ...pyhwException import OSUnsupportedException
 
 
@@ -8,6 +7,10 @@ class ShellDetect:
 
     def getShellInfo(self):
         if self.OS in ["linux", "macos", "freebsd"]:
+            from .unix import ShellDetectUnix
             return ShellDetectUnix().getShellInfo()
+        elif self.OS == "windows":
+            from .windows import ShellDetectWindows
+            return ShellDetectWindows().getShellInfo()
         else:
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/shell/shellInfo.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ShellInfo:
+    def __init__(self):
+        self.shell = ""
+        self.version = ""
+        self.path = ""
+        self.info = ""