pyhw 0.2.0b0__py3-none-any.whl → 0.7.3__py3-none-any.whl

pyhw/__init__.py

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

pyhw/__main__.py

@@ -9,15 +9,16 @@ from .backend.os import OSDetect
 from .backend.cpu import CPUDetect
 from .backend.gpu import GPUDetect
 from .backend.memory import MemoryDetect
+from .backend.nic import NICDetect
+from .backend.npu import NPUDetect
 from .pyhwUtil import createDataString
 from .pyhwUtil import getOS, selectOSLogo
 
 
 def main():
     current_os = getOS()
-    print("This is a test version of PyHw. Currently, it only supports Linux and macOS.")
-    if current_os != "linux" and current_os != "macos":
-        print(f"Only Linux and macOS is supported for now. Current os: {current_os}")
+    if current_os not in ["linux", "macos", "freebsd"]:
+        print(f"Only Linux, macOS, and FreeBSD is supported for now. Current os: {current_os}")
         return
     data = Data()
     data.title = TitleDetect(os=current_os).getTitle().title
@@ -31,6 +32,12 @@ def main():
     if gpu_info.number > 0:
         data.GPU = gpu_info.gpus
     data.Memory = MemoryDetect(os=current_os).getMemoryInfo().memory
+    nic_info = NICDetect(os=current_os).getNICInfo()
+    if nic_info.number > 0:
+        data.NIC = nic_info.nics
+    npu_info = NPUDetect(os=current_os).getNPUInfo()
+    if npu_info.number > 0:
+        data.NPU = npu_info.npus
 
     Printer(logo_os=selectOSLogo(OSDetect(os=current_os).getOSInfo().id), data=createDataString(data)).cPrint()
 

pyhw/backend/backendBase.py

@@ -19,3 +19,5 @@ class Data:
     CPU = "Default Value"
     GPU = ["Default Value"]
     Memory = "Default Value"
+    NIC = ["Default Value"]
+    NPU = ["Default Value"]

pyhw/backend/cpu/bsd.py

@@ -0,0 +1,12 @@
+from .cpuInfo import CPUInfo
+from ...pyhwUtil import sysctlGetString, sysctlGetInt, getArch
+
+
+class CPUDetectBSD:
+    def __init__(self):
+        self.__cpuInfo = CPUInfo()
+
+    def getCPUInfo(self):
+        self.__cpuInfo.cpu = sysctlGetString("hw.model")
+        return self.__cpuInfo
+

pyhw/backend/cpu/cpuBase.py

@@ -1,5 +1,6 @@
 from .linux import CPUDetectLinux
 from .macos import CPUDetectMacOS
+from .bsd import CPUDetectBSD
 from ...pyhwException import OSUnsupportedException
 
 
@@ -12,5 +13,7 @@ class CPUDetect:
             return CPUDetectLinux().getCPUInfo()
         elif self.OS == "macos":
             return CPUDetectMacOS().getCPUInfo()
+        elif self.OS == "freebsd":
+            return CPUDetectBSD().getCPUInfo()
         else:
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/cpu/linux.py

@@ -10,6 +10,9 @@ class CPUDetectLinux:
     def getCPUInfo(self):
         self.__getCPUInfo()
         self.__modelClean()
+        self.__handleSBC()
+        if self.__cpuInfo.model == "":
+            self.__cpuInfo.model = "Unknown"
         if self.__cpuInfo.model != "":
             self.__cpuInfo.cpu = self.__cpuInfo.model
             if self.__cpuInfo.cores != "":
@@ -51,3 +54,26 @@ class CPUDetectLinux:
     def __modelClean(self):
         self.__cpuInfo.model = self.__cpuInfo.model.replace("(R)", "")
         self.__cpuInfo.model = self.__cpuInfo.model.replace("(TM)", "")
+
+    def __handleSBC(self):
+        # some values should be double-checked
+        # Info source: https://github.com/raspberrypi/firmware/tree/master/boot
+        if os.path.exists("/sys/firmware/devicetree/base/compatible"):
+            try:
+                with open("/sys/firmware/devicetree/base/compatible", "r") as f:
+                    compatible = f.read().strip()
+            except FileNotFoundError:
+                compatible = ""
+            if "raspberrypi" in compatible:
+                model = compatible.split(",")[-1]
+                if model.startswith("bcm"):
+                    self.__cpuInfo.model = model.upper()
+            elif "orangepi" in compatible:
+                if "allwinner" in compatible:
+                    model = compatible.split(",")[-1]
+                    if model.startswith("sun"):
+                        self.__cpuInfo.model = f"Allwinner {model.split('-')[-1].upper()} ({model})"
+        else:
+            pass
+
+

pyhw/backend/cpu/macos.py

@@ -64,6 +64,8 @@ class CPUDetectMacOS:
             "Apple M3": "4.05 GHz",
             "Apple M3 Pro": "4.05 GHz",
             "Apple M3 Max": "4.05 GHz",
-            "Apple M4": "4.40 GHz"
+            "Apple M4": "4.40 GHz",
+            "Apple M4 Pro": "4.40 GHz",
+            "Apple M4 Max": "4.40 GHz"
         }
         self.__cpuInfo.frequency = freq.get(self.__cpuInfo.model, "Unknown")

pyhw/backend/gpu/bsd.py

@@ -0,0 +1,7 @@
+from .linux import GPUDetectLinux
+
+
+class GPUDetectBSD(GPUDetectLinux):
+    def __init__(self):
+        super().__init__()
+

pyhw/backend/gpu/gpuBase.py

@@ -1,5 +1,6 @@
 from .linux import GPUDetectLinux
 from .macos import GPUDetectMacOS
+from .bsd import GPUDetectBSD
 
 
 class GPUDetect:
@@ -11,5 +12,7 @@ class GPUDetect:
             return GPUDetectLinux().getGPUInfo()
         elif self.OS == "macos":
             return GPUDetectMacOS().getGPUInfo()
+        elif self.OS == "freebsd":
+            return GPUDetectBSD().getGPUInfo()
         else:
             raise NotImplementedError("Unsupported operating system")

pyhw/backend/gpu/linux.py

@@ -2,6 +2,7 @@ import subprocess
 from .gpuInfo import GPUInfo
 from ..cpu import CPUDetect
 from ...pyhwUtil import getArch
+import pypci
 
 
 class GPUDetectLinux:
@@ -10,22 +11,21 @@ class GPUDetectLinux:
 
     def getGPUInfo(self):
         self.__getGPUInfo()
+        self.__sortGPUList()
         return self.__gpuInfo
 
     def __getGPUInfo(self):
-        try:
-            pci_info = subprocess.run(["bash", "-c", "lspci"], capture_output=True, text=True).stdout.strip()
-        except subprocess.SubprocessError:
-            return
-        if len(pci_info) == 0:  # no pcie devices found
+        gpu_devices = pypci.PCI().FindAllVGA()
+        if len(gpu_devices) == 0:
             self.__handleNonePciDevices()
-        for line in pci_info.split("\n"):
-            if "VGA" in line or "Display" in line or "3D" in line:
-                gpu = line.split(": ")[1]
-                self.__gpuInfo.gpus.append(gpu)
+        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
-        if self.__gpuInfo.number == 0:
-            self.__handleNonePciDevices()  # fallback to a sbc device detection method
 
     def __handleNonePciDevices(self):
         # if detector can't find any VGA/Display/3D GPUs, assume the host is a sbc device, this function is a placeholder for a more advanced method.
@@ -35,3 +35,12 @@ class GPUDetectLinux:
         else:
             self.__gpuInfo.number = 1
             self.__gpuInfo.gpus.append("Not found")
+
+    @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/gpu/macos.py

@@ -2,6 +2,8 @@ from .gpuInfo import GPUInfo
 from ...pyhwUtil import getArch
 import json
 import subprocess
+import ctypes
+from pathlib import Path
 
 
 class GPUDetectMacOS:
@@ -32,24 +34,49 @@ class GPUDetectMacOS:
             self.__gpuInfo.gpus.append(f'{gpu.get("sppci_model")} ({gpu.get("sppci_cores")} cores) [SOC Integrated]')
 
     def __getGPUIntel(self):
-        gpus = list()
-        try:
-            gpu_info_dict = json.loads(subprocess.check_output(["system_profiler", "SPDisplaysDataType", "-json"]))
-            if 'SPDisplaysDataType' in gpu_info_dict:
-                gpus = gpu_info_dict['SPDisplaysDataType']
-                self.__gpuInfo.number = len(gpus)
-            else:
-                pass
-        except Exception:
-            return
+        if self.__getGPUIOKit():
+            pass
+        else:  # fallback to the default implementation
+            gpus = list()
+            try:
+                gpu_info_dict = json.loads(subprocess.check_output(["system_profiler", "SPDisplaysDataType", "-json"]))
+                if 'SPDisplaysDataType' in gpu_info_dict:
+                    gpus = gpu_info_dict['SPDisplaysDataType']
+                    self.__gpuInfo.number = len(gpus)
+                else:
+                    pass
+            except Exception:
+                return
 
-        for gpu in gpus:
-            if self.__handleVendor(gpu.get("spdisplays_vendor")) == "Intel":    # Integrated GPU
-                self.__gpuInfo.gpus.append(f'{gpu.get("sppci_model")} [CPU Integrated]')
-            elif self.__handleVendor(gpu.get("spdisplays_vendor")) == "AMD":    # dGPU
-                self.__gpuInfo.gpus.append(f'{gpu.get("sppci_model")} [Discrete]')
-            elif self.__handleVendor(gpu.get("spdisplays_vendor")) == "Nvidia":    # Since current macOS does not support NVIDIA GPUs, this condition is not applicable
-                pass
+            for gpu in gpus:
+                if self.__handleVendor(gpu.get("spdisplays_vendor")) == "Intel":    # Integrated GPU
+                    self.__gpuInfo.gpus.append(f'{gpu.get("sppci_model")} [CPU Integrated]')
+                elif self.__handleVendor(gpu.get("spdisplays_vendor")) == "AMD":    # dGPU
+                    self.__gpuInfo.gpus.append(f'{gpu.get("sppci_model")} {gpu.get("spdisplays_vram")} [Discrete]')
+                elif self.__handleVendor(gpu.get("spdisplays_vendor")) == "Nvidia":    # Since current macOS does not support NVIDIA GPUs, this condition is not applicable
+                    pass
+
+    def __getGPUIOKit(self):
+        try:
+            package_root = Path(__file__).resolve().parent.parent.parent
+            lib = ctypes.CDLL(f"{package_root}/library/lib/iokitGPULib.dylib")
+            lib.getGPUInfo.restype = ctypes.c_char_p
+            gpu_info = lib.getGPUInfo()
+            gpus = gpu_info.decode('utf-8').split("; ")
+            self.__gpuInfo.number = len(gpus)
+            for gpu in gpus:
+                info_list = gpu.split(", ")
+                model = info_list[0]
+                vendor_id = info_list[1]
+                vram = round(int(info_list[2]) / 1024, None)
+                if self.__handleVendorID(vendor_id) == "Intel":    # Integrated GPU
+                    self.__gpuInfo.gpus.append(f'{model} [CPU Integrated]')
+                elif self.__handleVendorID(vendor_id) == "AMD":    # dGPU
+                    self.__gpuInfo.gpus.append(f'{model} {vram} GB [Discrete]')
+            return True
+        except Exception as e:
+            # print(f"An error occurred while getting GPU info using IOKit: {e}")
+            return False
 
     @staticmethod
     def __handleVendor(vendor):
@@ -61,3 +88,13 @@ class GPUDetectMacOS:
             return "AMD"
         else:
             return vendor
+
+    @staticmethod
+    def __handleVendorID(vendor_id):
+        if vendor_id == "0x8086":
+            return "Intel"
+        elif vendor_id == "0x1002":
+            return "AMD"
+        else:
+            return vendor_id
+

pyhw/backend/host/bsd.py

@@ -0,0 +1,13 @@
+from .linux import HostDetectLinux
+
+
+class HostDetectBSD(HostDetectLinux):
+    def __init__(self):
+        HostDetectLinux.__init__(self)
+
+    def getHostInfo(self):
+        self._hostInfo.name = f"General {self._arch} FreeBSD Host"
+        self._hostInfo.version = ""
+        self._hostInfo.model = self._hostInfo.name + " " + self._hostInfo.version
+        return self._hostInfo
+

pyhw/backend/host/hostBase.py

@@ -1,6 +1,7 @@
 from .linux import HostDetectLinux
 from .macos import HostDetectMacOS
 from .windows import HostDetectWindows
+from .bsd import HostDetectBSD
 from ...pyhwException import OSUnsupportedException
 
 
@@ -13,6 +14,8 @@ class HostDetect:
             return HostDetectLinux().getHostInfo()
         elif self.OS == "macos":
             return HostDetectMacOS().getHostInfo()
+        elif self.OS == "freebsd":
+            return HostDetectBSD().getHostInfo()
         elif self.OS == "windows":
             pass
         else:

pyhw/backend/host/linux.py

@@ -1,35 +1,62 @@
 """
     In dev.
 """
-from ...pyhwUtil import getArch
+from ...pyhwUtil import getArch, getDocker
 from .hostInfo import HostInfo
+import os
 
 
 class HostDetectLinux:
     def __init__(self):
-        self.__hostInfo = HostInfo()
-        self.__arch = getArch()
+        self._hostInfo = HostInfo()
+        self._arch = getArch()
+        self._docker = getDocker()
 
     def getHostInfo(self):
-        self.__getModel()
-        return self.__hostInfo
+        self._getModel()
+        return self._hostInfo
 
-    def __getModel(self):
-        if self.__arch in ["x86_64", "x86"]:
-            try:
-                with open("/sys/devices/virtual/dmi/id/product_name", "r") as f:
-                    self.__hostInfo.name = f.read().strip()
-                with open("/sys/devices/virtual/dmi/id/product_version", "r") as f:
-                    self.__hostInfo.version = f.read().strip()
-                self.__hostInfo.model = self.__hostInfo.name + " " + self.__hostInfo.version
-            except FileNotFoundError:
-                pass
-        elif self.__arch in ["aarch64", "arm32"]:
-            try:
-                with open("/sys/firmware/devicetree/base/model", "r") as f:
-                    self.__hostInfo.model = f.read().strip()
-            except FileNotFoundError:
-                pass
+    def _getModel(self):
+        if self._docker:
+            self._hostInfo.name = f"General {self._arch} Docker Host"
+            self._hostInfo.version = ""
+            self._hostInfo.model = self._hostInfo.name + " " + self._hostInfo.version
+        else:
+            if self._arch in ["x86_64", "x86"]:
+                try:
+                    with open("/sys/devices/virtual/dmi/id/product_name", "r") as f:
+                        product_name = f.read().strip()
+                        if product_name.startswith("To be filled by O.E.M."):
+                            self._hostInfo.name = f"General {self._arch} Host"
+                        else:
+                            self._hostInfo.name = product_name
+                    with open("/sys/devices/virtual/dmi/id/product_version", "r") as f:
+                        version = f.read().strip()
+                        if version.startswith("To be filled by O.E.M."):
+                            self._hostInfo.version = ""
+                        else:
+                            self._hostInfo.version = version
+                    self._hostInfo.model = self._hostInfo.name + " " + self._hostInfo.version
+                except FileNotFoundError:
+                    pass
+            elif self._arch in ["aarch64", "arm32"]:
+                # try to find dmi folder since some arm based desktops and servers may have same structure as x86_64 machines.
+                if os.path.exists("/sys/devices/virtual/dmi/id"):
+                    try:
+                        with open("/sys/devices/virtual/dmi/id/product_name", "r") as f:
+                            self._hostInfo.name = f.read().strip()
+                        with open("/sys/devices/virtual/dmi/id/product_version", "r") as f:
+                            self._hostInfo.version = f.read().strip()
+                        self._hostInfo.model = self._hostInfo.name + " " + self._hostInfo.version
+                    except FileNotFoundError:
+                        pass
+                else:
+                    # some single board computers may not have dmi folder, try to find model name in device tree.
+                    try:
+                        with open("/sys/firmware/devicetree/base/model", "r") as f:
+                            self._hostInfo.model = f.read().strip()
+                    except FileNotFoundError:
+                        pass
 
     def __getHostFamily(self):
         pass

pyhw/backend/host/macos.py

@@ -172,6 +172,16 @@ class HostDetectMacOS:
 
         elif hw_model.startswith("Mac"):
             version = hw_model[len("Mac"):]
+            if self.__hwModelCheck(version, "16,3"):
+                return "iMac (24-inch, 2024, Four Thunderbolt / USB 4 ports)"
+            if self.__hwModelCheck(version, "16,2"):
+                return "iMac (24-inch, 2024, Two Thunderbolt / USB 4 ports)"
+            if self.__hwModelCheck(version, "16,1") or self.__hwModelCheck(version, "16,6") or self.__hwModelCheck(version, "16,8"):
+                return "MacBook Pro (14-inch, 2024, Three Thunderbolt 4 ports)"
+            if self.__hwModelCheck(version, "16,5") or self.__hwModelCheck(version, "16,7"):
+                return "MacBook Pro (16-inch, 2024, Three Thunderbolt 4 ports)"
+            if self.__hwModelCheck(version, "16,10") or self.__hwModelCheck(version, "16,15"):
+                return "Mac mini (M4, 2024)"
             if self.__hwModelCheck(version, "15,13"):
                 return "MacBook Air (15-inch, M3, 2024)"
             if self.__hwModelCheck(version, "15,2"):
@@ -262,7 +272,7 @@ class HostDetectMacOS:
             if self.__hwModelCheck(version, "9,1"):
                 return "iMac (24/20-inch, Early 2009)"
 
-        return "Unknown Mac Model"
+        return hw_model
 
     @staticmethod
     def __hwModelCheck(version: str, target: str):

pyhw/backend/kernel/kernelBase.py

@@ -7,9 +7,7 @@ class KernelDetect:
         self.OS = os
 
     def getKernelInfo(self):
-        if self.OS == "linux":
-            return KernelDetectUnix().getKernelInfo()
-        elif self.OS == "macos":
+        if self.OS in ["linux", "macos", "freebsd"]:
             return KernelDetectUnix().getKernelInfo()
         elif self.OS == "windows":
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/memory/bsd.py

@@ -0,0 +1,11 @@
+from .linux import MemoryDetectLinux
+
+
+class MemoryDetectBSD(MemoryDetectLinux):
+    def __init__(self):
+        MemoryDetectLinux.__init__(self)
+
+    def getMemoryInfo(self):
+        self._memoryInfo.memory = f"Pass"
+        return self._memoryInfo
+

pyhw/backend/memory/linux.py

@@ -3,22 +3,22 @@ from .memoryInfo import MemoryInfo
 
 class MemoryDetectLinux:
     def __init__(self):
-        self.__memoryInfo = MemoryInfo()
+        self._memoryInfo = MemoryInfo()
 
     def getMemoryInfo(self):
-        self.__getMemory()
-        self.__memoryInfo.memory = f"{self.__memoryInfo.used} MiB / {self.__memoryInfo.total} MiB"
-        return self.__memoryInfo
+        self._getMemory()
+        self._memoryInfo.memory = f"{self._memoryInfo.used} MiB / {self._memoryInfo.total} MiB"
+        return self._memoryInfo
 
-    def __getMemory(self):
+    def _getMemory(self):
         try:
             with open("/proc/meminfo", "r") as file:
                 for line in file:
                     if line.startswith("MemTotal:"):
-                        self.__memoryInfo.total = round(float(line.split(":")[1].strip()[:-3]) / 1024, 2)
+                        self._memoryInfo.total = round(float(line.split(":")[1].strip()[:-3]) / 1024, 2)
                     elif line.startswith("MemAvailable:"):
-                        self.__memoryInfo.available = round(float(line.split(":")[1].strip()[:-3]) / 1024, 2)
-                self.__memoryInfo.used = round(self.__memoryInfo.total - self.__memoryInfo.available, 2)
+                        self._memoryInfo.available = round(float(line.split(":")[1].strip()[:-3]) / 1024, 2)
+                self._memoryInfo.used = round(self._memoryInfo.total - self._memoryInfo.available, 2)
         except FileNotFoundError:
             pass
 

pyhw/backend/memory/memoryBase.py

@@ -1,5 +1,6 @@
 from .linux import MemoryDetectLinux
 from .macos import MemoryDetectMacOS
+from .bsd import MemoryDetectBSD
 
 
 class MemoryDetect:
@@ -11,5 +12,7 @@ class MemoryDetect:
             return MemoryDetectLinux().getMemoryInfo()
         elif self.OS == "macos":
             return MemoryDetectMacOS().getMemoryInfo()
+        elif self.OS == "freebsd":
+            return MemoryDetectBSD().getMemoryInfo()
         else:
             raise NotImplementedError("Unsupported operating system")

pyhw/backend/nic/__init__.py

@@ -0,0 +1,4 @@
+from .nicBase import NICDetect
+
+
+__all__ = ["NICDetect"]

pyhw/backend/nic/bsd.py

@@ -0,0 +1,7 @@
+from .linux import NICDetectLinux
+
+
+class NICDetectBSD(NICDetectLinux):
+    def __init__(self):
+        NICDetectLinux.__init__(self)
+

pyhw/backend/nic/linux.py

@@ -0,0 +1,41 @@
+import subprocess
+from .nicInfo import NICInfo
+from ...pyhwUtil import getArch
+from ...pyhwException import BackendException
+import pypci
+
+
+class NICDetectLinux:
+    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):
+        # placeholder for a more advanced method.
+        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/nic/macos.py

@@ -0,0 +1,27 @@
+from .nicInfo import NICInfo
+import subprocess
+
+
+class NICDetectMacOS:
+    def __init__(self):
+        self.__nicInfo = NICInfo()
+
+    def getNICInfo(self):
+        self.__getNICInfo()
+        return self.__nicInfo
+
+    def __getNICInfo(self):
+        # Placeholder for a more advanced method.
+        try:
+            interface = subprocess.run(["bash", "-c", "route get default | grep interface"], capture_output=True, text=True).stdout.strip().split(":")[1]
+            if_ip = subprocess.run(["bash", "-c", f"ipconfig getifaddr {interface}"], capture_output=True, text=True).stdout.strip()
+            self.__nicInfo.nics.append(f"{interface} @ {if_ip}")
+            self.__nicInfo.number += 1
+        except:
+            self.__handleError()
+
+    def __handleError(self):
+        self.__nicInfo.nics.append("en0")
+        self.__nicInfo.number = 1
+
+

pyhw/backend/nic/nicBase.py

@@ -0,0 +1,25 @@
+from .linux import NICDetectLinux
+from .macos import NICDetectMacOS
+from .bsd import NICDetectBSD
+
+
+class NICDetect:
+    """
+    Class for network interface (NIC) detection.
+    """
+    def __init__(self, os):
+        self.OS = os
+
+    def getNICInfo(self):
+        """
+        Detects the network interfaces (NICs) connected to the system.
+        :return: dataclass NICInfo, direct attr: nics
+        """
+        if self.OS == "linux":
+            return NICDetectLinux().getNICInfo()
+        elif self.OS == "macos":
+            return NICDetectMacOS().getNICInfo()
+        elif self.OS == "freebsd":
+            return NICDetectBSD().getNICInfo()
+        else:
+            raise NotImplementedError("Unsupported operating system")

pyhw/backend/nic/nicInfo.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class NICInfo:
+    def __init__(self):
+        self.number = 0
+        self.nics = []

pyhw/backend/npu/__init__.py

@@ -0,0 +1,5 @@
+from .npuBase import NPUDetect
+
+__all__ = ['NPUDetect']
+
+

pyhw/backend/npu/bsd.py

@@ -0,0 +1,6 @@
+from .linux import NPUDetectLinux
+
+
+class NPUDetectBSD(NPUDetectLinux):
+    def __init__(self):
+        NPUDetectLinux.__init__(self)