pyhw 0.1.2b0__tar.gz → 0.2.0b0__tar.gz

{pyhw-0.1.2b0/src/pyhw.egg-info → pyhw-0.2.0b0}/PKG-INFO

@@ -1,9 +1,7 @@
 Metadata-Version: 2.1
 Name: pyhw
-Version: 0.1.2b0
+Version: 0.2.0b0
 Summary: PyHw, a neofetch-like command line tool for fetching system information but written mostly in python.
-Home-page: https://github.com/xiaoran007/pyhw
-Author: Xiao Ran
 Author-email: Xiao Ran <xiaoran.007@icloud.com>
 License: BSD-3-Clause
 Project-URL: homepage, https://github.com/xiaoran007/pyhw
@@ -15,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.2b0 → pyhw-0.2.0b0}/README.md

@@ -1,5 +1,10 @@
 # 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.2b0 → pyhw-0.2.0b0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyhw"
-version = "0.1.2b"
+version = "0.2.0b"
 description = "PyHw, a neofetch-like command line tool for fetching system information but written mostly in python."
 authors = [
     { name = "Xiao Ran", email = "xiaoran.007@icloud.com" }

pyhw-0.2.0b0/src/pyhw/__main__.py

@@ -0,0 +1,39 @@
+from .frontend import Printer
+from .backend import Data
+from .backend.title import TitleDetect
+from .backend.host import HostDetect
+from .backend.kernel import KernelDetect
+from .backend.shell import ShellDetect
+from .backend.uptime import UptimeDetect
+from .backend.os import OSDetect
+from .backend.cpu import CPUDetect
+from .backend.gpu import GPUDetect
+from .backend.memory import MemoryDetect
+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}")
+        return
+    data = Data()
+    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=current_os).getOSInfo().id), data=createDataString(data)).cPrint()
+
+
+if __name__ == "__main__":
+    main()

{pyhw-0.1.2b0 → pyhw-0.2.0b0}/src/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-0.2.0b0/src/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-0.1.2b0 → pyhw-0.2.0b0}/src/pyhw/backend/cpu/linux.py

@@ -1,22 +1,15 @@
-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.cpu = self.__cpuInfo.model
             if self.__cpuInfo.cores != "":
@@ -52,5 +45,9 @@ 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):
+        self.__cpuInfo.model = self.__cpuInfo.model.replace("(R)", "")
+        self.__cpuInfo.model = self.__cpuInfo.model.replace("(TM)", "")

pyhw-0.2.0b0/src/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-0.1.2b0 → pyhw-0.2.0b0}/src/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-0.2.0b0/src/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-0.1.2b0 → pyhw-0.2.0b0}/src/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-0.2.0b0/src/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-0.1.2b0 → pyhw-0.2.0b0}/src/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-0.2.0b0/src/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-0.1.2b0 → pyhw-0.2.0b0}/src/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):