pyhw 0.1.3b0__tar.gz → 0.2.1b0__tar.gz

{pyhw-0.1.3b0/src/pyhw.egg-info → pyhw-0.2.1b0}/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.1
 Name: pyhw
-Version: 0.1.3b0
+Version: 0.2.1b0
 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
 Project-URL: homepage, https://github.com/xiaoran007/pyhw
+Keywords: neofetch,system information,command line tool,python,hardware information,fastfetch,fetching
+Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
@@ -13,19 +15,36 @@ 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)
 
-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 🤔)
+![Static Badge](https://img.shields.io/badge/macOS-brightgreen)
+![Static Badge](https://img.shields.io/badge/Linux-blue)
+
+
+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 🤔).
 
 There are already a lot of similar tools so you can choose any of them; they're all essentially no different. If you want to try this tool, just install it directly by pip.
 ```shell
 pip install pyhw
 ```
+To upgrade pyhw:
+```shell
+pip install pyhw --upgrade
+```
 You can then use this tool directly from the command line with the following command, just like neofetch.
 ```shell
 pyhw
 ```
 
+## Supported (Tested) OS
+* macOS arm64, x86_64
+* debian-based distro x86_64
+* RaspberryPi OS arm64
+
+
 ## Build from source
 ### Build tools
 Make sure the following Python build tools are already installed.

{pyhw-0.1.3b0 → pyhw-0.2.1b0}/README.md

@@ -1,17 +1,34 @@
 # 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)
 
-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 🤔)
+![Static Badge](https://img.shields.io/badge/macOS-brightgreen)
+![Static Badge](https://img.shields.io/badge/Linux-blue)
+
+
+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 🤔).
 
 There are already a lot of similar tools so you can choose any of them; they're all essentially no different. If you want to try this tool, just install it directly by pip.
 ```shell
 pip install pyhw
 ```
+To upgrade pyhw:
+```shell
+pip install pyhw --upgrade
+```
 You can then use this tool directly from the command line with the following command, just like neofetch.
 ```shell
 pyhw
 ```
 
+## Supported (Tested) OS
+* macOS arm64, x86_64
+* debian-based distro x86_64
+* RaspberryPi OS arm64
+
+
 ## Build from source
 ### Build tools
 Make sure the following Python build tools are already installed.

{pyhw-0.1.3b0 → pyhw-0.2.1b0}/pyproject.toml

@@ -4,8 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyhw"
-version = "0.1.3b"
+version = "0.2.1b"
 description = "PyHw, a neofetch-like command line tool for fetching system information but written mostly in python."
+keywords = ["neofetch", "system information", "command line tool", "python", "hardware information", "fastfetch", "fetching"]
 authors = [
     { name = "Xiao Ran", email = "xiaoran.007@icloud.com" }
 ]
@@ -13,6 +14,7 @@ readme = "README.md"
 license = {text = "BSD-3-Clause"}
 requires-python = ">=3.9"
 classifiers = [
+    "Development Status :: 4 - Beta",
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: BSD License",
     "Operating System :: OS Independent"

pyhw-0.2.1b0/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.3b0 → pyhw-0.2.1b0}/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.1b0/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.3b0 → pyhw-0.2.1b0}/src/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-0.2.1b0/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.3b0 → pyhw-0.2.1b0}/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.1b0/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.3b0 → pyhw-0.2.1b0}/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.1b0/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.3b0 → pyhw-0.2.1b0}/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.1b0/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.2.1b0/src/pyhw/backend/host/linux.py

@@ -0,0 +1,51 @@
+"""
+    In dev.
+"""
+from ...pyhwUtil import getArch
+from .hostInfo import HostInfo
+import os
+
+
+class HostDetectLinux:
+    def __init__(self):
+        self.__hostInfo = HostInfo()
+        self.__arch = getArch()
+
+    def getHostInfo(self):
+        self.__getModel()
+        return self.__hostInfo
+
+    def __getModel(self):
+        if self.__arch in ["x86_64", "x86"]:
+            try:
+                with open("/sys/devices/virtual/dmi/id/product_name", "r") as f:
+                    self.__hostInfo.name = f.read().strip()
+                with open("/sys/devices/virtual/dmi/id/product_version", "r") as f:
+                    self.__hostInfo.version = f.read().strip()
+                self.__hostInfo.model = self.__hostInfo.name + " " + self.__hostInfo.version
+            except FileNotFoundError:
+                pass
+        elif self.__arch in ["aarch64", "arm32"]:
+            # try 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
+
+    def __getHostProductName(self):
+        pass