pyhw 0.1.3b0__py3-none-any.whl → 0.2.1b0__py3-none-any.whl

pyhw/__main__.py

@@ -14,23 +14,25 @@ from .pyhwUtil import getOS, selectOSLogo
 
 
 def main():
-    print("This is a test version of PyHw. Currently, it only supports Linux. Currently there are some display issues on small terminals.")
-    if getOS() != "linux":
-        print(f"Only Linux is supported for now. Current os: {getOS()}")
+    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}")
         return
     data = Data()
-    data.title = TitleDetect(os="linux").getTitle().title
-    data.Host = HostDetect(os="linux").getHostInfo().model
-    data.Kernel = KernelDetect(os="linux").getKernelInfo().kernel
-    data.Shell = ShellDetect(os="linux").getShellInfo().info
-    data.Uptime = UptimeDetect(os="linux").getUptime().uptime
-    data.OS = OSDetect(os="linux").getOSInfo().prettyName
-    data.CPU = CPUDetect(os="linux").getCPUInfo().cpu
-    if GPUDetect(os="linux").getGPUInfo().number > 0:
-        data.GPU = GPUDetect(os="linux").getGPUInfo().gpus
-    data.Memory = MemoryDetect(os="linux").getMemoryInfo().memory
+    data.title = TitleDetect(os=current_os).getTitle().title
+    data.Host = HostDetect(os=current_os).getHostInfo().model
+    data.Kernel = KernelDetect(os=current_os).getKernelInfo().kernel
+    data.Shell = ShellDetect(os=current_os).getShellInfo().info
+    data.Uptime = UptimeDetect(os=current_os).getUptime().uptime
+    data.OS = OSDetect(os=current_os).getOSInfo().prettyName
+    data.CPU = CPUDetect(os=current_os).getCPUInfo().cpu
+    gpu_info = GPUDetect(os=current_os).getGPUInfo()
+    if gpu_info.number > 0:
+        data.GPU = gpu_info.gpus
+    data.Memory = MemoryDetect(os=current_os).getMemoryInfo().memory
 
-    Printer(logo_os=selectOSLogo(OSDetect(os="linux").getOSInfo().id), data=createDataString(data)).cPrint()
+    Printer(logo_os=selectOSLogo(OSDetect(os=current_os).getOSInfo().id), data=createDataString(data)).cPrint()
 
 
 if __name__ == "__main__":

pyhw/backend/cpu/cpuBase.py

@@ -1,4 +1,5 @@
 from .linux import CPUDetectLinux
+from .macos import CPUDetectMacOS
 from ...pyhwException import OSUnsupportedException
 
 
@@ -9,5 +10,7 @@ class CPUDetect:
     def getCPUInfo(self):
         if self.OS == "linux":
             return CPUDetectLinux().getCPUInfo()
+        elif self.OS == "macos":
+            return CPUDetectMacOS().getCPUInfo()
         else:
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/cpu/cpuInfo.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class CPUInfo:
+    """
+    Class to store CPU information. Print key: cpu
+    """
+    def __init__(self):
+        self.cpu = ""
+        self.model = ""
+        self.cores = ""
+        self.frequency = ""

pyhw/backend/cpu/linux.py

@@ -1,23 +1,17 @@
-from dataclasses import dataclass
 import re
 import os
-
-
-@dataclass
-class CPUInfoLinux:
-    cpu = ""
-    model = ""
-    cores = ""
-    frequency = ""
+from .cpuInfo import CPUInfo
 
 
 class CPUDetectLinux:
     def __init__(self):
-        self.__cpuInfo = CPUInfoLinux()
+        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 != "":
@@ -53,7 +47,7 @@ class CPUDetectLinux:
             else:
                 for line in cpu_info.split("\n"):
                     if line.startswith("cpu MHz") or line.startswith("clock"):
-                        self.__cpuInfo.frequency = float(line.split(":")[1].strip()) / 1000  # Ghz
+                        self.__cpuInfo.frequency = f"{round(float(line.split(':')[1].strip()) / 1000, 2)} Ghz"  # Ghz
                         break
 
     def __modelClean(self):

pyhw/backend/cpu/macos.py

@@ -0,0 +1,69 @@
+from .cpuInfo import CPUInfo
+from ...pyhwUtil import sysctlGetString, sysctlGetInt, getArch
+
+
+class CPUDetectMacOS:
+    def __init__(self):
+        self.__cpuInfo = CPUInfo()
+        self.__arch = getArch()
+        self.__pCore = 0
+        self.__eCore = 0
+
+    def getCPUInfo(self):
+        if self.__arch == "aarch64":
+            self.__getCPUModel()
+            self.__AppleSiliconBaseFrequency()
+            self.__handleAppleSilicon()
+            self.__cpuInfo.cpu = f"{self.__cpuInfo.model} ({self.__pCore}P, {self.__eCore}E) @ {self.__cpuInfo.frequency}"
+        else:
+            self.__getCPUModel()
+            self.__getCPUCores()
+            self.__getCPUFrequency()
+            # need test on Intel Macs.
+            self.__cpuInfo.cpu = f"{self.__cpuInfo.model.replace('CPU', f'({self.__cpuInfo.cores})')}"
+        return self.__cpuInfo
+
+    def __getCPUModel(self):
+        model = sysctlGetString("machdep.cpu.brand_string")
+        model = model.replace("(R)", "")
+        model = model.replace("(TM)", "")
+        self.__cpuInfo.model = model
+
+    def __getCPUCores(self):
+        cores = sysctlGetString("hw.logicalcpu_max")
+        self.__cpuInfo.cores = cores
+
+    def __getCPUFrequency(self):
+        # sysctl doesn't provide the exact CPU frequency on Apple Silicon Macs, there are some indirect methods
+        # to get the CPU frequency, but can not integrate with Python directly.
+        # C-Based helper module will be added later.
+        # See https://github.com/fastfetch-cli/fastfetch/blob/dev/src/detection/cpu/cpu_apple.c for more details.
+        freq = sysctlGetString("hw.cpufrequency")
+        self.__cpuInfo.frequency = freq
+
+    def __handleAppleSilicon(self):
+        nlevels = sysctlGetInt("hw.nperflevels")
+        if nlevels is not None and nlevels == 2:    # currently, Apple Silicon chip only has 2 performance levels.
+            pcore = sysctlGetInt("hw.perflevel0.logicalcpu_max")    # level 0 is P-core
+            ecore = sysctlGetInt("hw.perflevel1.logicalcpu_max")    # level 1 is E-core
+            if pcore is not None and ecore is not None:
+                self.__pCore = pcore
+                self.__eCore = ecore
+
+    def __AppleSiliconBaseFrequency(self):
+        # see https://en.wikipedia.org/wiki/Apple_silicon#M_series for more details.
+        freq = {
+            "Apple M1": "2.30 GHz",
+            "Apple M1 Pro": "2.32 GHz",
+            "Apple M1 Max": "2.32 GHz",
+            "Apple M1 Ultra": "2.32 GHz",
+            "Apple M2": "3.50 GHz",
+            "Apple M2 Pro": "3.50 GHz",
+            "Apple M2 Max": "3.69 GHz",
+            "Apple M2 Ultra": "3.70 Ghz",
+            "Apple M3": "4.05 GHz",
+            "Apple M3 Pro": "4.05 GHz",
+            "Apple M3 Max": "4.05 GHz",
+            "Apple M4": "4.40 GHz"
+        }
+        self.__cpuInfo.frequency = freq.get(self.__cpuInfo.model, "Unknown")

pyhw/backend/gpu/gpuBase.py

@@ -1,4 +1,5 @@
 from .linux import GPUDetectLinux
+from .macos import GPUDetectMacOS
 
 
 class GPUDetect:
@@ -8,5 +9,7 @@ class GPUDetect:
     def getGPUInfo(self):
         if self.OS == "linux":
             return GPUDetectLinux().getGPUInfo()
+        elif self.OS == "macos":
+            return GPUDetectMacOS().getGPUInfo()
         else:
             raise NotImplementedError("Unsupported operating system")

pyhw/backend/gpu/gpuInfo.py

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

pyhw/backend/gpu/linux.py

@@ -1,18 +1,12 @@
 import subprocess
-from dataclasses import dataclass
+from .gpuInfo import GPUInfo
 from ..cpu import CPUDetect
 from ...pyhwUtil import getArch
 
 
-@dataclass
-class GPUInfoLinux:
-    number = 0
-    gpus = []
-
-
 class GPUDetectLinux:
     def __init__(self):
-        self.__gpuInfo = GPUInfoLinux()
+        self.__gpuInfo = GPUInfo()
 
     def getGPUInfo(self):
         self.__getGPUInfo()
@@ -37,7 +31,7 @@ class GPUDetectLinux:
         # 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.
         if getArch() == "aarch64" or getArch() == "arm32":
             self.__gpuInfo.number = 1
-            self.__gpuInfo.gpus.append(f"{CPUDetect(os='linux').getCPUInfo().model} (SOC Integrated Graphics)")
+            self.__gpuInfo.gpus.append(f"{CPUDetect(os='linux').getCPUInfo().model} [SOC Integrated]")
         else:
             self.__gpuInfo.number = 1
             self.__gpuInfo.gpus.append("Not found")

pyhw/backend/gpu/macos.py

@@ -0,0 +1,63 @@
+from .gpuInfo import GPUInfo
+from ...pyhwUtil import getArch
+import json
+import subprocess
+
+
+class GPUDetectMacOS:
+    def __init__(self):
+        self.__gpuInfo = GPUInfo()
+        self.__arch = getArch()
+
+    def getGPUInfo(self):
+        if self.__arch == "aarch64":
+            self.__getGPUAppleSilicon()
+        else:   # Does not consider powerPC based Macs.
+            self.__getGPUIntel()
+        return self.__gpuInfo
+
+    def __getGPUAppleSilicon(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
+
+        for gpu in gpus:
+            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
+
+        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
+
+    @staticmethod
+    def __handleVendor(vendor):
+        if vendor == "sppci_vendor_Apple":
+            return "Apple"
+        elif vendor == "sppci_vendor_intel":
+            return "Intel"
+        elif vendor == "sppci_vendor_amd":
+            return "AMD"
+        else:
+            return vendor

pyhw/backend/host/hostBase.py

@@ -12,7 +12,7 @@ class HostDetect:
         if self.OS == "linux":
             return HostDetectLinux().getHostInfo()
         elif self.OS == "macos":
-            pass
+            return HostDetectMacOS().getHostInfo()
         elif self.OS == "windows":
             pass
         else:

pyhw/backend/host/hostInfo.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class HostInfo:
+    model = ""
+    family = ""
+    name = ""
+    version = ""
+    sku = ""
+    serial = ""
+    uuid = ""
+    vendor = ""

pyhw/backend/host/linux.py

@@ -2,24 +2,13 @@
     In dev.
 """
 from ...pyhwUtil import getArch
-from dataclasses import dataclass
-
-
-@dataclass
-class HostInfoLinux:
-    model = ""
-    family = ""
-    name = ""
-    version = ""
-    sku = ""
-    serial = ""
-    uuid = ""
-    vendor = ""
+from .hostInfo import HostInfo
+import os
 
 
 class HostDetectLinux:
     def __init__(self):
-        self.__hostInfo = HostInfoLinux()
+        self.__hostInfo = HostInfo()
         self.__arch = getArch()
 
     def getHostInfo(self):
@@ -37,11 +26,23 @@ class HostDetectLinux:
             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
+            # 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

@@ -1,5 +1,269 @@
 """
     In dev.
 """
+from .hostInfo import HostInfo
+from ...pyhwUtil import sysctlGetString
+
+
 class HostDetectMacOS:
-    pass
+    def __init__(self):
+        self.__hostInfo = HostInfo()
+        self.__HWModel = ""
+
+    def getHostInfo(self):
+        self.__getHWModel()
+        self.__hostInfo.model = self.__handleMacName(self.__HWModel)
+        return self.__hostInfo
+
+    def __getHWModel(self):
+        self.__HWModel = sysctlGetString("hw.model")
+
+    def __handleMacName(self, hw_model: str):
+        # This part of the code is directly re-implemented from the fastfetch project. It seems that there is no
+        # more elegant way to get the product name of the Mac.
+        # See https://github.com/fastfetch-cli/fastfetch/blob/dev/src/detection/host/host_apple.c for more details.
+        if hw_model.startswith("MacBookPro"):
+            version = hw_model[len("MacBookPro"):]
+            if self.__hwModelCheck(version, "18,3") or self.__hwModelCheck(version, "18,4"):
+                return "MacBook Pro (14-inch, 2021)"
+            if self.__hwModelCheck(version, "18,1") or self.__hwModelCheck(version, "18,2"):
+                return "MacBook Pro (16-inch, 2021)"
+            if self.__hwModelCheck(version, "17,1"):
+                return "MacBook Pro (13-inch, M1, 2020)"
+            if self.__hwModelCheck(version, "16,3"):
+                return "MacBook Pro (13-inch, 2020, Two Thunderbolt 3 ports)"
+            if self.__hwModelCheck(version, "16,2"):
+                return "MacBook Pro (13-inch, 2020, Four Thunderbolt 3 ports)"
+            if self.__hwModelCheck(version, "16,4") or self.__hwModelCheck(version, "16,1"):
+                return "MacBook Pro (16-inch, 2019)"
+            if self.__hwModelCheck(version, "15,4"):
+                return "MacBook Pro (13-inch, 2019, Two Thunderbolt 3 ports)"
+            if self.__hwModelCheck(version, "15,3"):
+                return "MacBook Pro (15-inch, 2019)"
+            if self.__hwModelCheck(version, "15,2"):
+                return "MacBook Pro (13-inch, 2018/2019, Four Thunderbolt 3 ports)"
+            if self.__hwModelCheck(version, "15,1"):
+                return "MacBook Pro (15-inch, 2018/2019)"
+            if self.__hwModelCheck(version, "14,3"):
+                return "MacBook Pro (15-inch, 2017)"
+            if self.__hwModelCheck(version, "14,2"):
+                return "MacBook Pro (13-inch, 2017, Four Thunderbolt 3 ports)"
+            if self.__hwModelCheck(version, "14,1"):
+                return "MacBook Pro (13-inch, 2017, Two Thunderbolt 3 ports)"
+            if self.__hwModelCheck(version, "13,3"):
+                return "MacBook Pro (15-inch, 2016)"
+            if self.__hwModelCheck(version, "13,2"):
+                return "MacBook Pro (13-inch, 2016, Four Thunderbolt 3 ports)"
+            if self.__hwModelCheck(version, "13,1"):
+                return "MacBook Pro (13-inch, 2016, Two Thunderbolt 3 ports)"
+            if self.__hwModelCheck(version, "12,1"):
+                return "MacBook Pro (Retina, 13-inch, Early 2015)"
+            if self.__hwModelCheck(version, "11,4") or self.__hwModelCheck(version, "11,5"):
+                return "MacBook Pro (Retina, 15-inch, Mid 2015)"
+            if self.__hwModelCheck(version, "11,2") or self.__hwModelCheck(version, "11,3"):
+                return "MacBook Pro (Retina, 15-inch, Late 2013/Mid 2014)"
+            if self.__hwModelCheck(version, "11,1"):
+                return "MacBook Pro (Retina, 13-inch, Late 2013/Mid 2014)"
+            if self.__hwModelCheck(version, "10,2"):
+                return "MacBook Pro (Retina, 13-inch, Late 2012/Early 2013)"
+            if self.__hwModelCheck(version, "10,1"):
+                return "MacBook Pro (Retina, 15-inch, Mid 2012/Early 2013)"
+            if self.__hwModelCheck(version, "9,2"):
+                return "MacBook Pro (13-inch, Mid 2012)"
+            if self.__hwModelCheck(version, "9,1"):
+                return "MacBook Pro (15-inch, Mid 2012)"
+            if self.__hwModelCheck(version, "8,3"):
+                return "MacBook Pro (17-inch, 2011)"
+            if self.__hwModelCheck(version, "8,2"):
+                return "MacBook Pro (15-inch, 2011)"
+            if self.__hwModelCheck(version, "8,1"):
+                return "MacBook Pro (13-inch, 2011)"
+            if self.__hwModelCheck(version, "7,1"):
+                return "MacBook Pro (13-inch, Mid 2010)"
+            if self.__hwModelCheck(version, "6,2"):
+                return "MacBook Pro (15-inch, Mid 2010)"
+            if self.__hwModelCheck(version, "6,1"):
+                return "MacBook Pro (17-inch, Mid 2010)"
+            if self.__hwModelCheck(version, "5,5"):
+                return "MacBook Pro (13-inch, Mid 2009)"
+            if self.__hwModelCheck(version, "5,3"):
+                return "MacBook Pro (15-inch, Mid 2009)"
+            if self.__hwModelCheck(version, "5,2"):
+                return "MacBook Pro (17-inch, Mid/Early 2009)"
+            if self.__hwModelCheck(version, "5,1"):
+                return "MacBook Pro (15-inch, Late 2008)"
+            if self.__hwModelCheck(version, "4,1"):
+                return "MacBook Pro (17/15-inch, Early 2008)"
+        elif hw_model.startswith("MacBookAir"):
+            version = hw_model[len("MacBookAir"):]
+            if self.__hwModelCheck(version, "10,1"):
+                return "MacBook Air (M1, 2020)"
+            if self.__hwModelCheck(version, "9,1"):
+                return "MacBook Air (Retina, 13-inch, 2020)"
+            if self.__hwModelCheck(version, "8,2"):
+                return "MacBook Air (Retina, 13-inch, 2019)"
+            if self.__hwModelCheck(version, "8,1"):
+                return "MacBook Air (Retina, 13-inch, 2018)"
+            if self.__hwModelCheck(version, "7,2"):
+                return "MacBook Air (13-inch, Early 2015/2017)"
+            if self.__hwModelCheck(version, "7,1"):
+                return "MacBook Air (11-inch, Early 2015)"
+            if self.__hwModelCheck(version, "6,2"):
+                return "MacBook Air (13-inch, Mid 2013/Early 2014)"
+            if self.__hwModelCheck(version, "6,1"):
+                return "MacBook Air (11-inch, Mid 2013/Early 2014)"
+            if self.__hwModelCheck(version, "5,2"):
+                return "MacBook Air (13-inch, Mid 2012)"
+            if self.__hwModelCheck(version, "5,1"):
+                return "MacBook Air (11-inch, Mid 2012)"
+            if self.__hwModelCheck(version, "4,2"):
+                return "MacBook Air (13-inch, Mid 2011)"
+            if self.__hwModelCheck(version, "4,1"):
+                return "MacBook Air (11-inch, Mid 2011)"
+            if self.__hwModelCheck(version, "3,2"):
+                return "MacBook Air (13-inch, Late 2010)"
+            if self.__hwModelCheck(version, "3,1"):
+                return "MacBook Air (11-inch, Late 2010)"
+            if self.__hwModelCheck(version, "2,1"):
+                return "MacBook Air (Mid 2009)"
+
+        elif hw_model.startswith("Macmini"):
+            version = hw_model[len("Macmini"):]
+            if self.__hwModelCheck(version, "9,1"):
+                return "Mac mini (M1, 2020)"
+            if self.__hwModelCheck(version, "8,1"):
+                return "Mac mini (2018)"
+            if self.__hwModelCheck(version, "7,1"):
+                return "Mac mini (Mid 2014)"
+            if self.__hwModelCheck(version, "6,1") or self.__hwModelCheck(version, "6,2"):
+                return "Mac mini (Late 2012)"
+            if self.__hwModelCheck(version, "5,1") or self.__hwModelCheck(version, "5,2"):
+                return "Mac mini (Mid 2011)"
+            if self.__hwModelCheck(version, "4,1"):
+                return "Mac mini (Mid 2010)"
+            if self.__hwModelCheck(version, "3,1"):
+                return "Mac mini (Early/Late 2009)"
+
+        elif hw_model.startswith("MacBook"):
+            version = hw_model[len("MacBook"):]
+            if self.__hwModelCheck(version, "10,1"):
+                return "MacBook (Retina, 12-inch, 2017)"
+            if self.__hwModelCheck(version, "9,1"):
+                return "MacBook (Retina, 12-inch, Early 2016)"
+            if self.__hwModelCheck(version, "8,1"):
+                return "MacBook (Retina, 12-inch, Early 2015)"
+            if self.__hwModelCheck(version, "7,1"):
+                return "MacBook (13-inch, Mid 2010)"
+            if self.__hwModelCheck(version, "6,1"):
+                return "MacBook (13-inch, Late 2009)"
+            if self.__hwModelCheck(version, "5,2"):
+                return "MacBook (13-inch, Early/Mid 2009)"
+
+        elif hw_model.startswith("MacPro"):
+            version = hw_model[len("MacPro"):]
+            if self.__hwModelCheck(version, "7,1"):
+                return "Mac Pro (2019)"
+            if self.__hwModelCheck(version, "6,1"):
+                return "Mac Pro (Late 2013)"
+            if self.__hwModelCheck(version, "5,1"):
+                return "Mac Pro (Mid 2010 - Mid 2012)"
+            if self.__hwModelCheck(version, "4,1"):
+                return "Mac Pro (Early 2009)"
+
+        elif hw_model.startswith("Mac"):
+            version = hw_model[len("Mac"):]
+            if self.__hwModelCheck(version, "15,13"):
+                return "MacBook Air (15-inch, M3, 2024)"
+            if self.__hwModelCheck(version, "15,2"):
+                return "MacBook Air (13-inch, M3, 2024)"
+            if self.__hwModelCheck(version, "15,3"):
+                return "MacBook Pro (14-inch, Nov 2023, Two Thunderbolt / USB 4 ports)"
+            if self.__hwModelCheck(version, "15,4"):
+                return "iMac (24-inch, 2023, Two Thunderbolt / USB 4 ports)"
+            if self.__hwModelCheck(version, "15,5"):
+                return "iMac (24-inch, 2023, Two Thunderbolt / USB 4 ports, Two USB 3 ports)"
+            if self.__hwModelCheck(version, "15,6") or self.__hwModelCheck(version, "15,8") or self.__hwModelCheck(version, "15,10"):
+                return "MacBook Pro (14-inch, Nov 2023, Three Thunderbolt 4 ports)"
+            if self.__hwModelCheck(version, "15,7") or self.__hwModelCheck(version, "15,9") or self.__hwModelCheck(version, "15,11"):
+                return "MacBook Pro (16-inch, Nov 2023, Three Thunderbolt 4 ports)"
+            if self.__hwModelCheck(version, "14,15"):
+                return "MacBook Air (15-inch, M2, 2023)"
+            if self.__hwModelCheck(version, "14,14"):
+                return "Mac Studio (M2 Ultra, 2023, Two Thunderbolt 4 front ports)"
+            if self.__hwModelCheck(version, "14,13"):
+                return "Mac Studio (M2 Max, 2023, Two USB-C front ports)"
+            if self.__hwModelCheck(version, "14,8"):
+                return "Mac Pro (2023)"
+            if self.__hwModelCheck(version, "14,6") or self.__hwModelCheck(version, "14,10"):
+                return "MacBook Pro (16-inch, 2023)"
+            if self.__hwModelCheck(version, "14,5") or self.__hwModelCheck(version, "14,9"):
+                return "MacBook Pro (14-inch, 2023)"
+            if self.__hwModelCheck(version, "14,3"):
+                return "Mac mini (M2, 2023, Two Thunderbolt 4 ports)"
+            if self.__hwModelCheck(version, "14,12"):
+                return "Mac mini (M2, 2023, Four Thunderbolt 4 ports)"
+            if self.__hwModelCheck(version, "14,7"):
+                return "MacBook Pro (13-inch, M2, 2022)"
+            if self.__hwModelCheck(version, "14,2"):
+                return "MacBook Air (M2, 2022)"
+            if self.__hwModelCheck(version, "13,1"):
+                return "Mac Studio (M1 Max, 2022, Two USB-C front ports)"
+            if self.__hwModelCheck(version, "13,2"):
+                return "Mac Studio (M1 Ultra, 2022, Two Thunderbolt 4 front ports)"
+
+        elif hw_model.startswith("iMac"):
+            version = hw_model[len("iMac"):]
+            if self.__hwModelCheck(version, "21,1"):
+                return "iMac (24-inch, M1, 2021, Two Thunderbolt / USB 4 ports, Two USB 3 ports)"
+            if self.__hwModelCheck(version, "21,2"):
+                return "iMac (24-inch, M1, 2021, Two Thunderbolt / USB 4 ports)"
+            if self.__hwModelCheck(version, "20,1") or self.__hwModelCheck(version, "20,2"):
+                return "iMac (Retina 5K, 27-inch, 2020)"
+            if self.__hwModelCheck(version, "19,1"):
+                return "iMac (Retina 5K, 27-inch, 2019)"
+            if self.__hwModelCheck(version, "19,2"):
+                return "iMac (Retina 4K, 21.5-inch, 2019)"
+            if self.__hwModelCheck(version, "Pro1,1"):
+                return "iMac Pro (2017)"
+            if self.__hwModelCheck(version, "18,3"):
+                return "iMac (Retina 5K, 27-inch, 2017)"
+            if self.__hwModelCheck(version, "18,2"):
+                return "iMac (Retina 4K, 21.5-inch, 2017)"
+            if self.__hwModelCheck(version, "18,1"):
+                return "iMac (21.5-inch, 2017)"
+            if self.__hwModelCheck(version, "17,1"):
+                return "iMac (Retina 5K, 27-inch, Late 2015)"
+            if self.__hwModelCheck(version, "16,2"):
+                return "iMac (Retina 4K, 21.5-inch, Late 2015)"
+            if self.__hwModelCheck(version, "16,1"):
+                return "iMac (21.5-inch, Late 2015)"
+            if self.__hwModelCheck(version, "15,1"):
+                return "iMac (Retina 5K, 27-inch, Late 2014 - Mid 2015)"
+            if self.__hwModelCheck(version, "14,4"):
+                return "iMac (21.5-inch, Mid 2014)"
+            if self.__hwModelCheck(version, "14,2"):
+                return "iMac (27-inch, Late 2013)"
+            if self.__hwModelCheck(version, "14,1"):
+                return "iMac (21.5-inch, Late 2013)"
+            if self.__hwModelCheck(version, "13,2"):
+                return "iMac (27-inch, Late 2012)"
+            if self.__hwModelCheck(version, "13,1"):
+                return "iMac (21.5-inch, Late 2012)"
+            if self.__hwModelCheck(version, "12,2"):
+                return "iMac (27-inch, Mid 2011)"
+            if self.__hwModelCheck(version, "12,1"):
+                return "iMac (21.5-inch, Mid 2011)"
+            if self.__hwModelCheck(version, "11,3"):
+                return "iMac (27-inch, Mid 2010)"
+            if self.__hwModelCheck(version, "11,2"):
+                return "iMac (21.5-inch, Mid 2010)"
+            if self.__hwModelCheck(version, "10,1"):
+                return "iMac (27/21.5-inch, Late 2009)"
+            if self.__hwModelCheck(version, "9,1"):
+                return "iMac (24/20-inch, Early 2009)"
+
+        return "Unknown Mac Model"
+
+    @staticmethod
+    def __hwModelCheck(version: str, target: str):
+        return version == target