pyhw 0.1.0b0__py3-none-any.whl

pyhw/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'

pyhw/__main__.py

@@ -0,0 +1,37 @@
+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
+
+
+def main():
+    print("This is a test version of PyHw. Currently, it only supports Linux.")
+    if getOS() != "linux":
+        print(f"Only Linux is supported for now. Current os: {getOS()}")
+        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
+
+    Printer(logo_os=OSDetect(os="linux").getOSInfo().id, data=createDataString(data)).cPrint()
+
+
+if __name__ == "__main__":
+    main()

pyhw/backend/__init__.py

@@ -0,0 +1,3 @@
+from .backendBase import Data
+
+__all__ = ["Data"]

pyhw/backend/backendBase.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Data:
+    title = "Default Value"
+    underline = "Default Value"
+    OS = "Default Value"
+    Host = "Default Value"
+    Kernel = "Default Value"
+    Uptime = "Default Value"
+    # Packages = ""
+    Shell = "Default Value"
+    # Resolution = ""
+    # DE = ""
+    # WM = ""
+    # WM_Theme = ""
+    # Terminal = ""
+    CPU = "Default Value"
+    GPU = ["Default Value"]
+    Memory = "Default Value"

pyhw/backend/cpu/__init__.py

@@ -0,0 +1,3 @@
+from .cpuBase import CPUDetect
+
+__all__ = ['CPUDetect']

pyhw/backend/cpu/cpuBase.py

@@ -0,0 +1,13 @@
+from .linux import CPUDetectLinux
+from ...pyhwException import OSUnsupportedException
+
+
+class CPUDetect:
+    def __init__(self, os):
+        self.OS = os
+
+    def getCPUInfo(self):
+        if self.OS == "linux":
+            return CPUDetectLinux().getCPUInfo()
+        else:
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/cpu/linux.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+import re
+import os
+
+
+@dataclass
+class CPUInfoLinux:
+    cpu = ""
+    model = ""
+    cores = ""
+    frequency = ""
+
+
+class CPUDetectLinux:
+    def __init__(self):
+        self.__cpuInfo = CPUInfoLinux()
+
+    def getCPUInfo(self):
+        self.__getCPUInfo()
+        if self.__cpuInfo.model != "":
+            self.__cpuInfo.cpu = self.__cpuInfo.model
+            if self.__cpuInfo.cores != "":
+                self.__cpuInfo.cpu += f" ({self.__cpuInfo.cores})"
+            if self.__cpuInfo.frequency != "":
+                self.__cpuInfo.cpu += f" @ {self.__cpuInfo.frequency}"
+        return self.__cpuInfo
+
+    def __getCPUInfo(self):
+        try:
+            with open("/proc/cpuinfo", "r") as f:
+                cpu_info = f.read()
+        except FileNotFoundError:
+            return
+        for line in cpu_info.split("\n"):
+            if (line.startswith("model name") or line.startswith("Hardware") or line.startswith("Processor") or
+                    line.startswith("cpu model") or line.startswith("chip type") or line.startswith("cpu type")):
+                model = line.split(":")[1].strip()
+                if "@" in model:
+                    self.__cpuInfo.model = model.split("@")[0].strip()
+                    self.__cpuInfo.frequency = model.split("@")[1].strip()
+                else:
+                    self.__cpuInfo.model = model
+                break
+        self.__cpuInfo.cores = len(re.findall(r"processor", cpu_info))
+        if self.__cpuInfo.frequency == "":
+            if os.path.exists("/sys/devices/system/cpu/cpu0/cpufreq"):
+                try:
+                    with open("/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq", "r") as f:
+                        self.__cpuInfo.frequency = f"{int(f.read()) / 1000 / 1000} Ghz"  # Ghz
+                except FileNotFoundError:
+                    pass
+            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
+                        break

pyhw/backend/gpu/__init__.py

@@ -0,0 +1,3 @@
+from .gpuBase import GPUDetect
+
+__all__ = ['GPUDetect']

pyhw/backend/gpu/gpuBase.py

@@ -0,0 +1,12 @@
+from .linux import GPUDetectLinux
+
+
+class GPUDetect:
+    def __init__(self, os):
+        self.OS = os
+
+    def getGPUInfo(self):
+        if self.OS == "linux":
+            return GPUDetectLinux().getGPUInfo()
+        else:
+            raise NotImplementedError("Unsupported operating system")

pyhw/backend/gpu/linux.py

@@ -0,0 +1,43 @@
+import subprocess
+from dataclasses import dataclass
+from ..cpu import CPUDetect
+from ...pyhwUtil import getArch
+
+
+@dataclass
+class GPUInfoLinux:
+    number = 0
+    gpus = []
+
+
+class GPUDetectLinux:
+    def __init__(self):
+        self.__gpuInfo = GPUInfoLinux()
+
+    def getGPUInfo(self):
+        self.__getGPUInfo()
+        return self.__gpuInfo
+
+    def __getGPUInfo(self):
+        try:
+            pci_info = subprocess.run(["bash", "-c", "lspci"], capture_output=True, text=True).stdout.strip()
+        except subprocess.SubprocessError:
+            return
+        if len(pci_info) == 0:  # no pcie devices found
+            self.__handleNonePciDevices()
+        for line in pci_info.split("\n"):
+            if "VGA" in line or "Display" in line or "3D" in line:
+                gpu = line.split(": ")[1]
+                self.__gpuInfo.gpus.append(gpu)
+                self.__gpuInfo.number += 1
+        if self.__gpuInfo.number == 0:
+            self.__handleNonePciDevices()  # fallback to a sbc device detection method
+
+    def __handleNonePciDevices(self):
+        # if detector can't find any VGA/Display/3D GPUs, assume the host is a sbc device, this function is a placeholder for a more advanced method.
+        if getArch() == "aarch64" or getArch() == "arm32":
+            self.__gpuInfo.number = 1
+            self.__gpuInfo.gpus.append(f"{CPUDetect(os='linux').getCPUInfo().model} (SOC Integrated Graphics)")
+        else:
+            self.__gpuInfo.number = 1
+            self.__gpuInfo.gpus.append("Not found")

pyhw/backend/host/__init__.py

@@ -0,0 +1,3 @@
+from .hostBase import HostDetect
+
+__all__ = ["HostDetect"]

pyhw/backend/host/hostBase.py

@@ -0,0 +1,19 @@
+from .linux import HostDetectLinux
+from .macos import HostDetectMacOS
+from .windows import HostDetectWindows
+from ...pyhwException import OSUnsupportedException
+
+
+class HostDetect:
+    def __init__(self, os):
+        self.OS = os
+
+    def getHostInfo(self):
+        if self.OS == "linux":
+            return HostDetectLinux().getHostInfo()
+        elif self.OS == "macos":
+            pass
+        elif self.OS == "windows":
+            pass
+        else:
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/host/linux.py

@@ -0,0 +1,50 @@
+"""
+    In dev.
+"""
+from ...pyhwUtil import getArch
+from dataclasses import dataclass
+
+
+@dataclass
+class HostInfoLinux:
+    model = ""
+    family = ""
+    name = ""
+    version = ""
+    sku = ""
+    serial = ""
+    uuid = ""
+    vendor = ""
+
+
+class HostDetectLinux:
+    def __init__(self):
+        self.__hostInfo = HostInfoLinux()
+        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:
+                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

pyhw/backend/host/macos.py

@@ -0,0 +1,5 @@
+"""
+    In dev.
+"""
+class HostDetectMacOS:
+    pass

pyhw/backend/host/windows.py

@@ -0,0 +1,5 @@
+"""
+    In dev.
+"""
+class HostDetectWindows:
+    pass

pyhw/backend/kernel/__init__.py

@@ -0,0 +1,3 @@
+from .kernelBase import KernelDetect
+
+__all__ = ['KernelDetect']

pyhw/backend/kernel/kernelBase.py

@@ -0,0 +1,17 @@
+from .linux import KernelDetectLinux
+from ...pyhwException import OSUnsupportedException
+
+
+class KernelDetect:
+    def __init__(self, os):
+        self.OS = os
+
+    def getKernelInfo(self):
+        if self.OS == "linux":
+            return KernelDetectLinux().getKernelInfo()
+        elif self.OS == "macos":
+            pass
+        elif self.OS == "windows":
+            pass
+        else:
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/kernel/linux.py

@@ -0,0 +1,47 @@
+"""
+    In dev.
+"""
+from dataclasses import dataclass
+import subprocess
+
+
+@dataclass
+class KernelInfoLinux:
+    name = ""
+    version = ""
+    machine = ""
+    kernel = ""
+
+
+class KernelDetectLinux:
+    def __init__(self):
+        self.__kernelInfo = KernelInfoLinux()
+
+    def getKernelInfo(self):
+        self.__getKernelName()
+        self.__getKernelVersion()
+        self.__getKernelMachine()
+        self.__kernelInfo.kernel = self.__kernelInfo.name + " " + self.__kernelInfo.version + " " + self.__kernelInfo.machine
+        return self.__kernelInfo
+
+    def __getKernelName(self):
+        try:
+            result = subprocess.run(['uname', '-s'], capture_output=True, text=True)
+            self.__kernelInfo.name = result.stdout.strip()
+        except subprocess.SubprocessError:
+            pass
+
+    def __getKernelVersion(self):
+        try:
+            result = subprocess.run(['uname', '-r'], capture_output=True, text=True)
+            self.__kernelInfo.version = result.stdout.strip()
+        except subprocess.SubprocessError:
+            pass
+
+    def __getKernelMachine(self):
+        try:
+            result = subprocess.run(['uname', '-m'], capture_output=True, text=True)
+            self.__kernelInfo.machine = result.stdout.strip()
+        except subprocess.SubprocessError:
+            pass
+

pyhw/backend/kernel/macos.py

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

pyhw/backend/kernel/windows.py

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

pyhw/backend/memory/__init__.py

@@ -0,0 +1,3 @@
+from .memoryBase import MemoryDetect
+
+__all__ = ['MemoryDetect']

pyhw/backend/memory/linux.py

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

pyhw/backend/memory/memoryBase.py

@@ -0,0 +1,12 @@
+from .linux import MemoryDetectLinux
+
+
+class MemoryDetect:
+    def __init__(self, os):
+        self.OS = os
+
+    def getMemoryInfo(self):
+        if self.OS == "linux":
+            return MemoryDetectLinux().getMemoryInfo()
+        else:
+            raise NotImplementedError("Unsupported operating system")

pyhw/backend/metal/t.py

@@ -0,0 +1,19 @@
+import ctypes
+
+
+mylib = ctypes.CDLL('./metalGPULib.dylib')
+
+mylib.backend_init.argtypes = []
+mylib.backend_init.restype = None
+
+mylib.get_default_device_name.argtypes = []
+mylib.get_default_device_name.restype = ctypes.c_char_p
+
+
+# Call the function
+mylib.backend_init()
+device_name = mylib.get_default_device_name()
+
+# Print the result
+print(f"Device Name: {device_name.decode('utf-8')}")
+

pyhw/backend/os/__init__.py

@@ -0,0 +1,3 @@
+from .osBase import OSDetect
+
+__all__ = ['OSDetect']

pyhw/backend/os/linux.py

@@ -0,0 +1,62 @@
+"""
+    In dev.
+"""
+from dataclasses import dataclass
+
+
+@dataclass
+class OSInfoLinux:
+    prettyName = ""
+    name = ""
+    id = ""
+    idLike = ""
+    variant = ""
+    variantID = ""
+    version = ""
+    versionID = ""
+    versionCodename = ""
+    codeName = ""
+    buildID = ""
+
+
+class OSDetectLinux:
+    def __init__(self):
+        self.__osInfo = OSInfoLinux()
+
+    def getOSInfo(self):
+        """
+        Detects the os distribution and its version.
+        :return: dataclass OSInfoLinux, direct attrs: prettyName
+        """
+        self.__getOSInfo()
+        return self.__osInfo
+
+    def __getOSInfo(self):
+        try:
+            with open("/etc/os-release", "r") as f:
+                for line in f:
+                    key, value = line.strip().split("=")
+                    if key == "PRETTY_NAME":
+                        self.__osInfo.prettyName = value.strip('"')
+                    elif key == "NAME":
+                        self.__osInfo.name = value.strip('"')
+                    elif key == "ID":
+                        self.__osInfo.id = value.strip('"')
+                    elif key == "ID_LIKE":
+                        self.__osInfo.idLike = value.strip('"')
+                    elif key == "VARIANT":
+                        self.__osInfo.variant = value.strip('"')
+                    elif key == "VARIANT_ID":
+                        self.__osInfo.variantID = value.strip('"')
+                    elif key == "VERSION":
+                        self.__osInfo.version = value.strip('"')
+                    elif key == "VERSION_ID":
+                        self.__osInfo.versionID = value.strip('"')
+                    elif key == "VERSION_CODENAME":
+                        self.__osInfo.versionCodename = value.strip('"')
+                    elif key == "CODE_NAME":
+                        self.__osInfo.codeName = value.strip('"')
+                    elif key == "BUILD_ID":
+                        self.__osInfo.buildID = value.strip('"')
+        except Exception:
+            pass

pyhw/backend/os/osBase.py

@@ -0,0 +1,13 @@
+from .linux import OSDetectLinux
+from ...pyhwException import OSUnsupportedException
+
+
+class OSDetect:
+    def __init__(self, os):
+        self.__OS = os
+
+    def getOSInfo(self):
+        if self.__OS == "linux":
+            return OSDetectLinux().getOSInfo()
+        else:
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/shell/__init__.py

@@ -0,0 +1,3 @@
+from .shellBase import ShellDetect
+
+__all__ = ['ShellDetect']

pyhw/backend/shell/shellBase.py

@@ -0,0 +1,13 @@
+from .unix import ShellDetectUnix
+from ...pyhwException import OSUnsupportedException
+
+
+class ShellDetect:
+    def __init__(self, os):
+        self.OS = os
+
+    def getShellInfo(self):
+        if self.OS == "linux" or self.OS == "macos":
+            return ShellDetectUnix().getShellInfo()
+        else:
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/shell/unix.py

@@ -0,0 +1,56 @@
+"""
+    In dev.
+"""
+from dataclasses import dataclass
+import os
+import subprocess
+
+
+@dataclass
+class ShellInfoUnix:
+    shell = ""
+    version = ""
+    path = ""
+    info = ""
+
+
+class ShellDetectUnix:
+    def __init__(self):
+        self.__shellInfo = ShellInfoUnix()
+
+    def getShellInfo(self):
+        self.__getShell()
+        self.__getVersion()
+        self.__shellInfo.info = self.__shellInfo.shell + " " + self.__shellInfo.version
+        return self.__shellInfo
+
+    def __getShell(self):
+        # Get the default shell, not the current shell.
+        shell_env = os.getenv("SHELL", "")
+        if shell_env != "":
+            self.__shellInfo.shell = shell_env.split("/")[-1]
+            self.__shellInfo.path = shell_env
+
+    def __getVersion(self):
+        shell = self.__shellInfo.shell
+        if shell != "":
+            if shell in ["sh", "ash", "dash", "es"]:
+                pass
+            elif shell == "bash":
+                try:
+                    result = subprocess.run(["bash", "-c", "echo $BASH_VERSION"], capture_output=True, text=True)
+                    self.__shellInfo.version = result.stdout.strip()
+                except subprocess.SubprocessError:
+                    pass
+            elif shell == "zsh":
+                try:
+                    result = subprocess.run(["zsh", "-c", "echo $ZSH_VERSION"], capture_output=True, text=True)
+                    self.__shellInfo.version = result.stdout.strip()
+                except subprocess.SubprocessError:
+                    pass
+
+
+
+
+
+

pyhw/backend/title/__init__.py

@@ -0,0 +1,3 @@
+from .titleBase import TitleDetect
+
+__all__ = ["TitleDetect"]

pyhw/backend/title/titleBase.py

@@ -0,0 +1,16 @@
+from .unix import TitleDetectUnix
+from .windows import TitleDetectWindows
+from ...pyhwException import OSUnsupportedException
+
+
+class TitleDetect:
+    def __init__(self, os):
+        self.OS = os
+
+    def getTitle(self):
+        if self.OS == "linux" or self.OS == "macos":
+            return TitleDetectUnix().getTitle()
+        elif self.OS == "windows":
+            return TitleDetectWindows().getTitle()
+        else:
+            raise OSUnsupportedException("Unsupported operating system")

pyhw/backend/title/unix.py

@@ -0,0 +1,33 @@
+"""
+ In dev.
+"""
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass
+class TitleInfoUnix:
+    username = ""
+    hostname = ""
+    title = ""
+
+
+class TitleDetectUnix:
+    def __init__(self):
+        self.__titleInfo = TitleInfoUnix()
+
+    def getTitle(self):
+        self.__getTitle()
+        return self.__titleInfo
+
+    def __getTitle(self):
+        try:
+            username_result = subprocess.run(['whoami'], capture_output=True, text=True)
+            self.__titleInfo.username = username_result.stdout.strip()
+            hostname_result = subprocess.run(['hostname'], capture_output=True, text=True)
+            self.__titleInfo.hostname = hostname_result.stdout.strip()
+            self.__titleInfo.title = f"{self.__titleInfo.username}@{self.__titleInfo.hostname}"
+        except Exception as e:
+            pass
+
+