pyhw 0.1.3b0__py3-none-any.whl → 0.2.0b0__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,19 +1,11 @@
-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()
@@ -53,7 +45,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,12 @@
     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
 
 
 class HostDetectLinux:
     def __init__(self):
-        self.__hostInfo = HostInfoLinux()
+        self.__hostInfo = HostInfo()
         self.__arch = getArch()
 
     def getHostInfo(self):

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

pyhw/backend/kernel/kernelBase.py

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

pyhw/backend/kernel/kernelInfo.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class KernelInfo:
+    def __init__(self):
+        self.name = ""
+        self.version = ""
+        self.machine = ""
+        self.kernel = ""

pyhw/backend/kernel/{linux.py → unix.py}

@@ -1,21 +1,10 @@
-"""
-    In dev.
-"""
-from dataclasses import dataclass
+from .kernelInfo import KernelInfo
 import subprocess
 
 
-@dataclass
-class KernelInfoLinux:
-    name = ""
-    version = ""
-    machine = ""
-    kernel = ""
-
-
-class KernelDetectLinux:
+class KernelDetectUnix:
     def __init__(self):
-        self.__kernelInfo = KernelInfoLinux()
+        self.__kernelInfo = KernelInfo()
 
     def getKernelInfo(self):
         self.__getKernelName()

pyhw/backend/memory/linux.py

@@ -1,17 +1,9 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class MemoryInfoLinux:
-    memory = ""
-    total = 0
-    available = 0
-    used = 0
+from .memoryInfo import MemoryInfo
 
 
 class MemoryDetectLinux:
     def __init__(self):
-        self.__memoryInfo = MemoryInfoLinux()
+        self.__memoryInfo = MemoryInfo()
 
     def getMemoryInfo(self):
         self.__getMemory()

pyhw/backend/memory/macos.py

@@ -0,0 +1,56 @@
+from .memoryInfo import MemoryInfo
+from ...pyhwUtil import sysctlGetInt
+import subprocess
+
+
+class MemoryDetectMacOS:
+    def __init__(self):
+        self.__memoryInfo = MemoryInfo()
+        self.__hw_pagesize = 0
+        self.__mem_total = 0
+        self.__active_count = 0
+        self.__inactive_count = 0
+        self.__speculative_count = 0
+        self.__wire_count = 0
+        self.__compressor_page_count = 0
+        self.__purgeable_count = 0
+        self.__external_page_count = 0
+        self.__mem_used = 0
+
+    def getMemoryInfo(self):
+        self.__getMemory()
+        self.__memoryInfo.total = self.__mem_total / 1024 / 1024  # Convert bytes to MiB
+        self.__memoryInfo.used = self.__mem_used / 1024 / 1024  # Convert bytes to MiB
+        self.__memoryInfo.memory = f"{round(self.__memoryInfo.used, 2)} MiB / {round(self.__memoryInfo.total, 2)} MiB"
+        return self.__memoryInfo
+
+    def __getMemory(self):
+        self.__hw_pagesize = sysctlGetInt("hw.pagesize")
+        self.__mem_total = sysctlGetInt("hw.memsize")
+        self.__getVMStat()
+        self.__mem_used = self.__hw_pagesize * (self.__active_count + self.__inactive_count + self.__speculative_count +
+                                                self.__wire_count + self.__compressor_page_count -
+                                                self.__purgeable_count - self.__external_page_count)
+
+    def __getVMStat(self):
+        try:
+            result = subprocess.run(["vm_stat"], capture_output=True, text=True)
+            vm_stats = result.stdout.split("\n")
+        except subprocess.SubprocessError:
+            vm_stats = []
+        for vm_stat in vm_stats:
+            if vm_stat.startswith("Pages active"):
+                self.__active_count = int(vm_stat.split(":")[1].strip().split(".")[0])
+            elif vm_stat.startswith("Pages inactive"):
+                self.__inactive_count = int(vm_stat.split(":")[1].strip().split(".")[0])
+            elif vm_stat.startswith("Pages speculative"):
+                self.__speculative_count = int(vm_stat.split(":")[1].strip().split(".")[0])
+            elif vm_stat.startswith("Pages wired down"):
+                self.__wire_count = int(vm_stat.split(":")[1].strip().split(".")[0])
+            elif vm_stat.startswith("Pages occupied by compressor"):  # compressor_page_count
+                self.__compressor_page_count = int(vm_stat.split(":")[1].strip().split(".")[0])
+            elif vm_stat.startswith("Pages purgeable"):
+                self.__purgeable_count = int(vm_stat.split(":")[1].strip().split(".")[0])
+            # miss external_page_count here
+            elif vm_stat.startswith("File-backed pages:"):
+                self.__external_page_count = int(vm_stat.split(":")[1].strip().split(".")[0])

pyhw/backend/memory/memoryBase.py

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

pyhw/backend/memory/memoryInfo.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class MemoryInfo:
+    def __init__(self):
+        self.memory = ""
+        self.total = 0
+        self.available = 0
+        self.used = 0

pyhw/backend/os/linux.py

@@ -1,27 +1,12 @@
 """
     In dev.
 """
-from dataclasses import dataclass
-
-
-@dataclass
-class OSInfoLinux:
-    prettyName = ""
-    name = ""
-    id = ""
-    idLike = ""
-    variant = ""
-    variantID = ""
-    version = ""
-    versionID = ""
-    versionCodename = ""
-    codeName = ""
-    buildID = ""
+from .osInfo import OSInfo
 
 
 class OSDetectLinux:
     def __init__(self):
-        self.__osInfo = OSInfoLinux()
+        self.__osInfo = OSInfo()
 
     def getOSInfo(self):
         """

pyhw/backend/os/macos.py

@@ -0,0 +1,36 @@
+from .osInfo import OSInfo
+from ...pyhwUtil import getArch
+import subprocess
+
+
+class OSDetectMacOS:
+    def __init__(self):
+        self.__osInfo = OSInfo()
+        self.__ProductName = ""
+        self.__ProductVersion = ""
+        self.__BuildVersion = ""
+        self.__VersionName = ""
+
+    def getOSInfo(self):
+        self.__getOS()
+        self.__osInfo.prettyName = f"{self.__ProductName} {self.__ProductVersion} {self.__BuildVersion} {getArch()}"
+        self.__osInfo.id = "macOS"
+        return self.__osInfo
+
+    def __getOS(self):
+        try:
+            result = subprocess.run(["sw_vers"], capture_output=True, text=True)
+            sw_vers = result.stdout.split("\n")
+        except subprocess.SubprocessError:
+            sw_vers = []
+        for sw_ver in sw_vers:
+            if sw_ver.startswith("ProductName:"):
+                self.__ProductName = sw_ver.split(":")[1].strip()
+            elif sw_ver.startswith("ProductVersion:"):
+                self.__ProductVersion = sw_ver.split(":")[1].strip()
+            elif sw_ver.startswith("BuildVersion:"):
+                self.__BuildVersion = sw_ver.split(":")[1].strip()
+
+    def __handelOSName(self):
+        # Add os name -- product version conversion logic in the future.
+        pass

pyhw/backend/os/osBase.py

@@ -1,4 +1,5 @@
 from .linux import OSDetectLinux
+from .macos import OSDetectMacOS
 from ...pyhwException import OSUnsupportedException
 
 
@@ -9,5 +10,7 @@ class OSDetect:
     def getOSInfo(self):
         if self.__OS == "linux":
             return OSDetectLinux().getOSInfo()
+        elif self.__OS == "macos":
+            return OSDetectMacOS().getOSInfo()
         else:
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/os/osInfo.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class OSInfo:
+    def __init__(self):
+        self.prettyName = ""
+        self.name = ""
+        self.id = ""
+        self.idLike = ""
+        self.variant = ""
+        self.variantID = ""
+        self.version = ""
+        self.versionID = ""
+        self.versionCodename = ""
+        self.codeName = ""
+        self.buildID = ""

pyhw/backend/uptime/linux.py

@@ -1,17 +1,12 @@
 """
     In dev.
 """
-from dataclasses import dataclass
-
-
-@dataclass
-class UptimeInfoLinux:
-    uptime = ""
+from .uptimeInfo import UptimeInfo
 
 
 class UptimeDetectLinux:
     def __init__(self):
-        self.__uptimeInfo = UptimeInfoLinux()
+        self.__uptimeInfo = UptimeInfo()
 
     def getUptimeInfo(self):
         self.__getUptime()
@@ -29,8 +24,8 @@ class UptimeDetectLinux:
             seconds = int(seconds)
             if days == 0:
                 if hours == 0:
-                    self.__uptimeInfo.uptime = f"{minutes} minutes {seconds} seconds"
+                    self.__uptimeInfo.uptime = f"{minutes} min {seconds} sec"
                 else:
-                    self.__uptimeInfo.uptime = f"{hours} hours {minutes} minutes {seconds} seconds"
+                    self.__uptimeInfo.uptime = f"{hours} hours {minutes} min {seconds} sec"
             else:
-                self.__uptimeInfo.uptime = f"{days} days {hours} hours {minutes} minutes {seconds} seconds"
+                self.__uptimeInfo.uptime = f"{days} days {hours} hours {minutes} min {seconds} sec"

pyhw/backend/uptime/macos.py

@@ -0,0 +1,40 @@
+from .uptimeInfo import UptimeInfo
+from ...pyhwUtil import sysctlGetString
+import re
+import subprocess
+
+
+class UptimeDetectMacOS:
+    def __init__(self):
+        self.__uptimeInfo = UptimeInfo()
+        self.__boot_time = 0
+        self.__now = 0
+
+    def getUptimeInfo(self):
+        self.__getUptime()
+        uptime_seconds = self.__now - self.__boot_time
+        hours, remainder = divmod(uptime_seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+        days, hours = divmod(hours, 24)
+        days = int(days)
+        hours = int(hours)
+        minutes = int(minutes)
+        seconds = int(seconds)
+        if days == 0:
+            if hours == 0:
+                self.__uptimeInfo.uptime = f"{minutes} min {seconds} sec"
+            else:
+                self.__uptimeInfo.uptime = f"{hours} hours {minutes} min {seconds} sec"
+        else:
+            self.__uptimeInfo.uptime = f"{days} days {hours} hours {minutes} min {seconds} sec"
+        return self.__uptimeInfo
+
+    def __getUptime(self):
+        result = sysctlGetString("kern.boottime")
+        match = re.search(r'sec = (\d+),', result)
+        if match:
+            self.__boot_time = int(match.group(1))
+        else:
+            return
+        self.__now = int(subprocess.check_output(["date", "+%s"]).decode().strip())
+

pyhw/backend/uptime/uptimeBase.py

@@ -1,4 +1,5 @@
 from .linux import UptimeDetectLinux
+from .macos import UptimeDetectMacOS
 from ...pyhwException import OSUnsupportedException
 
 
@@ -16,5 +17,7 @@ class UptimeDetect:
         """
         if self.OS == "linux":
             return UptimeDetectLinux().getUptimeInfo()
+        elif self.OS == "macos":
+            return UptimeDetectMacOS().getUptimeInfo()
         else:
             raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/uptime/uptimeInfo.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class UptimeInfo:
+    def __init__(self):
+        self.uptime = ""

pyhw/frontend/frontendBase.py

@@ -57,7 +57,7 @@ class Printer:
     def __DataPreprocess(self):
         header_color = self.__config.get("colorTitle")
         keys_color = self.__config.get("colorKeys")
-        self.__processed_data_lines.append("    " + colorPrefix(ColorSet.COLOR_MODE_BOLD) + colorPrefix(header_color) +
+        self.__processed_data_lines.append(" " + colorPrefix(ColorSet.COLOR_MODE_BOLD) + colorPrefix(header_color) +
                                            self.__data_lines[0].split("@")[0] + colorSuffix() + colorPrefix(ColorSet.COLOR_MODE_BOLD) +
                                            "@" + colorPrefix(header_color) +
                                            self.__data_lines[0].split("@")[1] + colorSuffix())

pyhw/pyhwUtil/__init__.py

@@ -1,3 +1,4 @@
 from .pyhwUtil import getOS, getArch, createDataString, selectOSLogo
+from .sysctlUtil import sysctlGetString, sysctlGetInt
 
-__all__ = ["getOS", "getArch", "createDataString", "selectOSLogo"]
+__all__ = ["getOS", "getArch", "createDataString", "selectOSLogo", "sysctlGetString", "sysctlGetInt"]

pyhw/pyhwUtil/pyhwUtil.py

@@ -2,10 +2,11 @@ import platform
 from ..backend import Data
 import os
 
+
 def getOS():
     """
     Get the os type in lower case.
-    :return: str, os type.
+    :return: str, os type, value in [windows, linux, macos, unknown].
     """
     system = platform.system()
     if system == "Windows":
@@ -17,6 +18,7 @@ def getOS():
     else:
         return "unknown"
 
+
 def getArch():
     """
     Get the machine architecture.
@@ -27,7 +29,7 @@ def getArch():
         return "x86_64"
     elif arch == "i386" or arch == "i686" or arch == "x86":
         return "x86"
-    elif arch == "aarch64":
+    elif arch == "aarch64" or arch == "arm64":
         return "aarch64"
     elif arch.find("arm") != -1:
         return "arm32"
@@ -36,18 +38,18 @@ def getArch():
 
 
 def createDataString(data: Data):
-    data_string = f"""
-    {data.title}
-    {"-"*len(data.title)}
-    OS: {data.OS}
-    Host: {data.Host}
-    Kernel: {data.Kernel}
-    Uptime: {data.Uptime}
-    Shell: {data.Shell}
-    CPU: {data.CPU}
-    GPU: {data.GPU[0]}
-    Memory: {data.Memory}
-    """
+    data_string = ""
+    data_string += f" {data.title}\n"
+    data_string += f" {'-'*len(data.title)}\n"
+    data_string += f" OS: {data.OS}\n"
+    data_string += f" Host: {data.Host}\n"
+    data_string += f" Kernel: {data.Kernel}\n"
+    data_string += f" Uptime: {data.Uptime}\n"
+    data_string += f" Shell: {data.Shell}\n"
+    data_string += f" CPU: {data.CPU}\n"
+    for gpu in data.GPU:
+        data_string += f" GPU: {gpu}\n"
+    data_string += f" Memory: {data.Memory}\n"
     return data_string
 
 
@@ -57,6 +59,8 @@ def selectOSLogo(os_id: str):
     :param os_id: str, os id.
     :return: str, logo id.
     """
+    if getOS() == "macos":
+        return os_id
     rows_str, columns_str = os.popen('stty size', 'r').read().split()
     rows = int(rows_str)
     columns = int(columns_str)

pyhw/pyhwUtil/sysctlUtil.py

@@ -0,0 +1,37 @@
+import subprocess
+
+
+def __sysctlGet(key):
+    """
+    Get value from sysctl by key.
+    :param key: str, sysctl key
+    :return: value of sysctl key or "" if not found
+    """
+    try:
+        output = subprocess.run(["sysctl", "-n", key], capture_output=True, text=True).stdout.strip()
+    except subprocess.SubprocessError:
+        output = ""
+    return output
+
+
+def sysctlGetString(key):
+    """
+    Get value from sysctl by key.
+    :param key: str, sysctl key
+    :return: value of sysctl key or "" if not found
+    """
+    return __sysctlGet(key)
+
+
+def sysctlGetInt(key):
+    """
+    Get value from sysctl by key.
+    :param key: str, sysctl key
+    :return: value of sysctl key as int or None if not found
+    """
+    value = __sysctlGet(key)
+    try:
+        res = int(value)
+    except Exception:
+        res = None
+    return res

{pyhw-0.1.3b0.dist-info → pyhw-0.2.0b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyhw
-Version: 0.1.3b0
+Version: 0.2.0b0
 Summary: PyHw, a neofetch-like command line tool for fetching system information but written mostly in python.
 Author-email: Xiao Ran <xiaoran.007@icloud.com>
 License: BSD-3-Clause
@@ -13,7 +13,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 
 # PyHw
-PyHw, a neofetch-like command line tool for fetching system information but written mostly in Python. Currently, this project is still in the initial stage, only part of the linux systems are supported. macOS support will be added soon.
+![PyPI - Downloads](https://img.shields.io/pypi/dw/pyhw?label=PyPI)
+![PyPI - Version](https://img.shields.io/pypi/v/pyhw?label=version)
+
+
+
+PyHw, a neofetch-like command line tool for fetching system information but written mostly in Python. **Currently, this project is still in the initial stage, only part of the linux systems and macOS are supported.**
 
 This project is a Python reimplementation of [neofetch](https://github.com/dylanaraps/neofetch) and references the [fastfetch](https://github.com/fastfetch-cli/fastfetch) project for logo style settings. Since this project is implemented in Python, it will be easier to maintain and extend than bash and c implementation. Also, this project only relies on the Python standard library, so you can run it on any device that has a Python environment (I hope so 🤔)
 

{pyhw-0.1.3b0.dist-info → pyhw-0.2.0b0.dist-info}/RECORD

@@ -1,31 +1,40 @@
 pyhw/__init__.py,sha256=IMjkMO3twhQzluVTo8Z6rE7Eg-9U79_LGKMcsWLKBkY,22
-pyhw/__main__.py,sha256=xWpiNAcjA1OVvUoGoKMSNYb7mk-7DfXldmwxoU1QOZw,1512
+pyhw/__main__.py,sha256=Ez3TaVt5NaTwEgDUnHzhUhyVMfrSDC2cSwv8AEmg8c4,1557
 pyhw/macos.py,sha256=kF973QvtEFky4m8RnYTJ-HWPuJi3625tvnWqJAT_DHM,4598
 pyhw/backend/__init__.py,sha256=knn_3Yroow1h0dqdrozk3zyy3vz-kQyNBRjR6OLmVoY,50
 pyhw/backend/backendBase.py,sha256=t9FKQPdK7yFZF0vrsXpjIUJNKrB-cXYeL5MDohlgguA,450
 pyhw/backend/cpu/__init__.py,sha256=5YfANJVRwNwTRodG0ENOgusrdN592aaSnfq5ok4dKTo,56
-pyhw/backend/cpu/cpuBase.py,sha256=VwVq7uazw90N02Sdvk1XK-K0MKgDA_FYDsLyWAxBzkc,348
-pyhw/backend/cpu/linux.py,sha256=hynJ12Aa1llRr9ozVwlW2KbX9Hre40bS_Lyf6eDFbFc,2357
+pyhw/backend/cpu/cpuBase.py,sha256=AGWqVjdvb82NiH4kxk3GERdBLwBNhkR23j2ei_l3S18,464
+pyhw/backend/cpu/cpuInfo.py,sha256=A_nNGElq9W7oZ5DFJowLdFBE0ZvXKr5h29E6TGAvbRc,251
+pyhw/backend/cpu/linux.py,sha256=J_oKa4BB_E5pBrMMuIORhNauXzPsyB2vsoJcUei9Ljg,2271
+pyhw/backend/cpu/macos.py,sha256=mnnH9ABiBgAiyA8-H9_tq2PC5OeneVLj67nMGoLDXh4,2873
 pyhw/backend/gpu/__init__.py,sha256=EpMjPvUaXt0LTNMvGmB8WgXbUB9keCxuOhu8NT3Re6o,56
-pyhw/backend/gpu/gpuBase.py,sha256=tTl9L0CKc49VkaEYGFEp_8A5Mmzfpd9h3DaKN0-FwFA,293
-pyhw/backend/gpu/linux.py,sha256=Ds0V7SZ-lhY4ZG2R6tGfcNJASHKXZfzIHJFgYYyvSMg,1529
+pyhw/backend/gpu/gpuBase.py,sha256=Ge0DX2P8_EB7ovM7glmPUnVsPJL3OUHV2t_1T5mimR0,409
+pyhw/backend/gpu/gpuInfo.py,sha256=d_z_z5DiZAg85wP0VOBQEU0QHdaK3qFqA2Tp9Eq8-Zs,133
+pyhw/backend/gpu/linux.py,sha256=Tj7ngrSvVpBGtx3HxuSNcWEXbTeIea8ef5qL341JQYQ,1448
+pyhw/backend/gpu/macos.py,sha256=sgrROfJC59KWjxfW2n90thVEjgDNYYLWo_pETDFPKQA,2308
 pyhw/backend/host/__init__.py,sha256=Efaj7-Oya7H8HdpZHQCLrwn-mcfPb-d6yfh4dzsE_7I,58
-pyhw/backend/host/hostBase.py,sha256=Pb4lHiXLYWe2pBL5PqYPubsTPhtIMCcdSa_Fvp5lybg,529
-pyhw/backend/host/linux.py,sha256=-iHCxqd54OKekBpADJFzR4Rusx3C781s5LGDIbjByAc,1336
-pyhw/backend/host/macos.py,sha256=imErUWZhyX8vfYYgSOBspXh-y0rQeZgyKIIawLa6ZEE,51
+pyhw/backend/host/hostBase.py,sha256=POyDW3f5JSWtEKyCfrVSBEddSwoywe_OBgUExCEuje8,563
+pyhw/backend/host/hostInfo.py,sha256=Xvz0LugPiCSWMkcDsp4p2rrojYFZauL6Q-gCZ6NLz5k,184
+pyhw/backend/host/linux.py,sha256=Ozl3tkDx-5OQ6mcocn4ap2KN7F8eE1JKB9g3qypHkxQ,1173
+pyhw/backend/host/macos.py,sha256=u-Orwcq0FCcr2eR9mOKUc85LGkyuiO6rZ-ggIwob92k,14593
 pyhw/backend/host/windows.py,sha256=rjDJaIs-5zspzFsNCMCh6m2yZXEXI0vccqeBpmAdEBk,53
 pyhw/backend/kernel/__init__.py,sha256=fGjwjpOhwA_PnsWbwoq102hwhTay2ufYKaTqxjSV2-I,65
-pyhw/backend/kernel/kernelBase.py,sha256=qroX2ekvZ3DmKCAYwDujGUef-CMG53joHLdGMZMLNUY,465
-pyhw/backend/kernel/linux.py,sha256=QRJrJ89O3U29MurxqhcnfPseH1V-L1Rz1xC0XwEdkRI,1317
-pyhw/backend/kernel/macos.py,sha256=SVa2FolhWLH9Lf6lL4nEM5w1UZlmYeMEAgc8-EgiKzw,56
+pyhw/backend/kernel/kernelBase.py,sha256=CMvBszl4_aP48YWnFI03I2GtngYStkcY4uDU3ub8C3E,555
+pyhw/backend/kernel/kernelInfo.py,sha256=QQYni0IVeFZ2IVNDC06U728Q01Rq3R6qRDYCxMjtJrY,189
+pyhw/backend/kernel/unix.py,sha256=XDV2GIjamERcmlrQFaKFZY-OJO1xj76Im_7lmg2uFzo,1192
 pyhw/backend/kernel/windows.py,sha256=lxZ7T9Ea0Qbq3pf_TjSAHSM2YTozC6ivv7dKdLOTl3s,58
 pyhw/backend/memory/__init__.py,sha256=zGBWxfPAAk8ivCBWPLJIpuD-lB7wUJT3x8u2jHiAoCY,65
-pyhw/backend/memory/linux.py,sha256=9-h3kaRjTNDlNBZv5sUJn_I_drw8lgQRHsimV_CO8zU,1030
-pyhw/backend/memory/memoryBase.py,sha256=AfqRw6dBw87M-MUVmD2fD-XGWFxXm64gnaOMd1NjzeI,308
+pyhw/backend/memory/linux.py,sha256=eEH3oOYdbANw2B0Ce32fDOidh1GhtEd_UPIo2GohBEA,929
+pyhw/backend/memory/macos.py,sha256=ur2HxmmmVkXmaxEcw_otphifVp_csfNMJdgt-idCq7M,2770
+pyhw/backend/memory/memoryBase.py,sha256=RFRWTByH25T3T77maxLyIRRoedIi5M8XLtVbvwBmjfY,433
+pyhw/backend/memory/memoryInfo.py,sha256=OQF165uEyuapAsi7cKacQYDRnKdrQHeldfyFwzS9N2g,186
 pyhw/backend/metal/t.py,sha256=52yv-JoXNfaIOfcxEEidIg0MoyFtzWvTRm550kQKPZA,391
 pyhw/backend/os/__init__.py,sha256=rPHQYdQK3qU6ZwwodqVoEWeqBnKffXlJyi4k3-8ViPY,53
-pyhw/backend/os/linux.py,sha256=ERDrZnvUiS0c3VSdlDje054aEcbtCeuIC4QsoTi6koM,2020
-pyhw/backend/os/osBase.py,sha256=3phvYUBcsOfv9_0ChkLIYAVp6nMLSZ40_Aop4T-emlg,347
+pyhw/backend/os/linux.py,sha256=fGVmJoKw65JdgWsJjbjAxOVqw0dqkmw-BQSb-TnSQQc,1782
+pyhw/backend/os/macos.py,sha256=bJU8-Uan8yRdAYWroN6wJ1XQA3US-2ikBLWwbDJhBeg,1261
+pyhw/backend/os/osBase.py,sha256=AA17HIwmWy7E6nCtqbojTNsHKtcNuehf51FxGcfXu7A,462
+pyhw/backend/os/osInfo.py,sha256=iLPc7INFHH3izascwooj4JBVgvBsSgVPXWBlFXG47mQ,378
 pyhw/backend/shell/__init__.py,sha256=SeQ7OLNSl_V1JCCWnJGjLilAWiSe9e5kgsMEt63TMS0,62
 pyhw/backend/shell/shellBase.py,sha256=mylNazVtTbCSzus-IPe1QwnuIGSFNP-z5vYKwTIl_yg,377
 pyhw/backend/shell/unix.py,sha256=COPpSE_wnuuSWDckTvBT0nNwLzgh8iPLicY8XghTSYM,1530
@@ -34,10 +43,12 @@ pyhw/backend/title/titleBase.py,sha256=pcnkiNn9N69yc4iicAmpMpC6G7HUMyGCh0V1jjGIP
 pyhw/backend/title/unix.py,sha256=9B-zLE8yhlWBnJ-6Aa-DmFmgMV9KdvvNU40drJIaNck,837
 pyhw/backend/title/windows.py,sha256=5bXR6yxHk3diVx92sjxPeD6fUVR5sKZJG3K4aM3CGn8,82
 pyhw/backend/uptime/__init__.py,sha256=X8RVhHWmHpyey0C4gcmrt_u1cHKowhAQRDMAxY3i7p0,65
-pyhw/backend/uptime/linux.py,sha256=k4sruxxkC0GW5gHSiMdwraP7KPb-KasinAiqHXddZIU,1107
-pyhw/backend/uptime/uptimeBase.py,sha256=_sloK7fKJB3qwKT-1jBJXJPkKB-eBDKqkn4ZbEvnru8,532
+pyhw/backend/uptime/linux.py,sha256=Sh05CgUjAOzPM8LSoZf4fCU-Cl5pwhSJSC7XJ-jFaHU,1027
+pyhw/backend/uptime/macos.py,sha256=8lTlR0WUzgGqUNspqegg4dP_j5ySOCTyFlXpyRBJ-Jw,1306
+pyhw/backend/uptime/uptimeBase.py,sha256=cP6aTPnFe6XQHgBX7YcDuuGHARI11ctMlyrrtsU-Opc,657
+pyhw/backend/uptime/uptimeInfo.py,sha256=TobPEV3MBT3Fiv3W6TOzD3a4MNW-vz2Oi_Trlcihu7k,114
 pyhw/frontend/__init__.py,sha256=xgv_iVv9w4cLXklbdtFWXu7J7KJxBCUw-ZcUQb_abFc,57
-pyhw/frontend/frontendBase.py,sha256=I3jSBeoVAp22XEiK1qOkVLN3Okx-kroU0Rn7fO7bVkw,3711
+pyhw/frontend/frontendBase.py,sha256=VjZ-_sV-awDJVLHBzG8z3YK3W92-SS_Q5-_Q0PgyB3w,3708
 pyhw/frontend/color/__init__.py,sha256=xk511qWwdYWEVjk_zOaC4fs81HtwR4ELr3wi1tTL824,191
 pyhw/frontend/color/colorConfig.py,sha256=jPjLzv67haEr6rNC2hoNLJLWHO5LQx4zBbLTy3FHA0E,2718
 pyhw/frontend/color/colorSet.py,sha256=spH8PlRu7capouf-yUgDHgoPCnM5aJ_ncascISZfz2g,1421
@@ -53,11 +64,12 @@ pyhw/frontend/logo/ascii/ubuntu.pyhw,sha256=l-Q0PfutxXYMwTojqeiM88063x4V0RBkZUHm
 pyhw/frontend/logo/ascii/ubuntu_small.pyhw,sha256=Xf8LSZdZUu9aEG3efhb1FUlUEuJ-3UztcIOJISpKhPw,229
 pyhw/pyhwException/__init__.py,sha256=8JsFvtF13g0Y5t4z9fRndDXtfCzuBM59jDf6PhWSFSk,220
 pyhw/pyhwException/pyhwException.py,sha256=wxuzFQa9g7XB1q9TUKO_55lw7wMEJMpzG8w1GVTFVa0,197
-pyhw/pyhwUtil/__init__.py,sha256=T87U8jEL-Z0jBZOYAzZpqu_8jBYRkqIONG6ZCARl8nc,137
-pyhw/pyhwUtil/pyhwUtil.py,sha256=MNAePrn17jNugorg8WLPhl_aFjfQxEpJQ8pBWLhd9gA,1611
-pyhw-0.1.3b0.dist-info/LICENSE,sha256=hJs6RBqSVCexbTsalkMLNFI5t06kekQEsSVaOt_-yLs,1497
-pyhw-0.1.3b0.dist-info/METADATA,sha256=YEXBHvwRKizHe3UkU0ef-1XhiNzUwnxenO8A6Uu-U3Y,1965
-pyhw-0.1.3b0.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-pyhw-0.1.3b0.dist-info/entry_points.txt,sha256=q-AB8im_QahpmNrmy4aPTJRGi0LlbNlnI3kF7s6pKss,44
-pyhw-0.1.3b0.dist-info/top_level.txt,sha256=7Inxvxt1TngEricKZEex9_WJZS3DbKYFUXDz4v5WHYU,5
-pyhw-0.1.3b0.dist-info/RECORD,,
+pyhw/pyhwUtil/__init__.py,sha256=PzeP9fXsIhvr3sUpJ4DxW9_H25DEIasBFfXd_NztfR4,226
+pyhw/pyhwUtil/pyhwUtil.py,sha256=Y_i_LUAAtQ8pLTna0mThzEh6ekrDfQ5JZ44Rtp2jSx4,1944
+pyhw/pyhwUtil/sysctlUtil.py,sha256=S-rUvqi7ZrMyMouIhxlyHEQ4agM7sCT1Y7uzs3Hu5-o,841
+pyhw-0.2.0b0.dist-info/LICENSE,sha256=hJs6RBqSVCexbTsalkMLNFI5t06kekQEsSVaOt_-yLs,1497
+pyhw-0.2.0b0.dist-info/METADATA,sha256=gmaNKWAc2PSWue_I__lz1BsVa7nMLSkz3O2ADqt62Tg,2084
+pyhw-0.2.0b0.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+pyhw-0.2.0b0.dist-info/entry_points.txt,sha256=q-AB8im_QahpmNrmy4aPTJRGi0LlbNlnI3kF7s6pKss,44
+pyhw-0.2.0b0.dist-info/top_level.txt,sha256=7Inxvxt1TngEricKZEex9_WJZS3DbKYFUXDz4v5WHYU,5
+pyhw-0.2.0b0.dist-info/RECORD,,

pyhw/backend/kernel/macos.py

@@ -1,7 +0,0 @@
-"""
-    In dev.
-"""
-
-
-class KernelDetectMacOS:
-    pass