HardwareMonitor 1.2.0__py3-none-win_amd64.whl

HardwareMonitor/Interop/PowerMonitor/__init__.py

@@ -0,0 +1,3 @@
+# Generated namespace __init__.py file for 'HardwareMonitor.Interop.PowerMonitor'
+
+from LibreHardwareMonitor.Interop.PowerMonitor import *

HardwareMonitor/Interop/PowerMonitor/__init__.pyi

@@ -0,0 +1,251 @@
+from HardwareMonitor._util.types import DateTime, UInt16, UInt32
+from typing import List, Set, overload
+
+
+class AVG(int):
+    AVG_22MS = 0
+    AVG_44MS = 1
+    AVG_89MS = 2
+    AVG_177MS = 3
+    AVG_354MS = 4
+    AVG_709MS = 5
+    AVG_1417MS = 6
+
+
+class CurrentScale(int):
+    CurrentScale5A = 0
+    CurrentScale10A = 1
+    CurrentScale15A = 2
+    CurrentScale20A = 3
+
+
+class DeviceConfigStructV1:
+    pass
+
+
+class DeviceConfigStructV2:
+    pass
+
+
+class DeviceConfigStructV3:
+    pass
+
+
+class DeviceData:
+    def __init__(self): ...
+    @property
+    def Connected(self) -> bool: ...
+    @property
+    def ExternalTemp1C(self) -> float: ...
+    @property
+    def ExternalTemp2C(self) -> float: ...
+    @property
+    def FaultLog(self) -> UInt16: ...
+    @property
+    def FaultStatus(self) -> UInt16: ...
+    @property
+    def FirmwareVersion(self) -> str: ...
+    @property
+    def HardwareRevision(self) -> str: ...
+    @property
+    def OnboardTempInC(self) -> float: ...
+    @property
+    def OnboardTempOutC(self) -> float: ...
+    @property
+    def PinCurrent(self) -> Set[float]: ...
+    @property
+    def PinVoltage(self) -> Set[float]: ...
+    @property
+    def PsuCapabilityW(self) -> int: ...
+    @property
+    def SumCurrentA(self) -> float: ...
+    @property
+    def SumPowerW(self) -> float: ...
+    @property
+    def Timestamp(self) -> DateTime: ...
+    @Connected.setter
+    def Connected(self, value: bool) -> None: ...
+    @ExternalTemp1C.setter
+    def ExternalTemp1C(self, value: float) -> None: ...
+    @ExternalTemp2C.setter
+    def ExternalTemp2C(self, value: float) -> None: ...
+    @FaultLog.setter
+    def FaultLog(self, value: UInt16) -> None: ...
+    @FaultStatus.setter
+    def FaultStatus(self, value: UInt16) -> None: ...
+    @FirmwareVersion.setter
+    def FirmwareVersion(self, value: str) -> None: ...
+    @HardwareRevision.setter
+    def HardwareRevision(self, value: str) -> None: ...
+    @OnboardTempInC.setter
+    def OnboardTempInC(self, value: float) -> None: ...
+    @OnboardTempOutC.setter
+    def OnboardTempOutC(self, value: float) -> None: ...
+    @PinCurrent.setter
+    def PinCurrent(self, value: Set[float]) -> None: ...
+    @PinVoltage.setter
+    def PinVoltage(self, value: Set[float]) -> None: ...
+    @PsuCapabilityW.setter
+    def PsuCapabilityW(self, value: int) -> None: ...
+    @Timestamp.setter
+    def Timestamp(self, value: DateTime) -> None: ...
+
+
+class DISPLAY_INVERSION(int):
+    DISPLAY_INVERSION_OFF = 0
+    DISPLAY_INVERSION_ON = 1
+    DISPLAY_INVERSION_NUM = 2
+
+
+class DisplayRotation(int):
+    DisplayRotation0 = 0
+    DisplayRotation180 = 1
+
+
+class FanConfigStruct:
+    pass
+
+
+class FanMode(int):
+    FanModeCurve = 0
+    FanModeFixed = 1
+
+
+class HpwrCapability(int):
+    PSU_CAP_600W = 0
+    PSU_CAP_450W = 1
+    PSU_CAP_300W = 2
+    PSU_CAP_150W = 3
+
+
+class NVM_CMD(int):
+    NVM_CMD_NONE = 0
+    NVM_CMD_LOAD = 1
+    NVM_CMD_STORE = 2
+    NVM_CMD_RESET = 3
+    NVM_CMD_LOAD_CAL = 4
+    NVM_CMD_STORE_CAL = 5
+    NVM_CMD_LOAD_CAL_FACTORY = 6
+    NVM_CMD_STORE_CAL_FACTORY = 7
+
+
+class PowerScale(int):
+    PowerScaleAuto = 0
+    PowerScale300W = 1
+    PowerScale600W = 2
+
+
+class PowerSensor:
+    pass
+
+
+class Screen(int):
+    ScreenMain = 0
+    ScreenSimple = 1
+    ScreenCurrent = 2
+    ScreenTemp = 3
+    ScreenStatus = 4
+
+
+class SCREEN_CMD(int):
+    SCREEN_GOTO_MAIN = 224
+    SCREEN_GOTO_SIMPLE = 225
+    SCREEN_GOTO_CURRENT = 226
+    SCREEN_GOTO_TEMP = 227
+    SCREEN_GOTO_STATUS = 228
+    SCREEN_GOTO_SAME = 239
+    SCREEN_PAUSE_UPDATES = 240
+    SCREEN_RESUME_UPDATES = 241
+
+
+class SensorStruct:
+    pass
+
+
+class SensorTs(int):
+    SENSOR_TS_IN = 0
+    SENSOR_TS_OUT = 1
+    SENSOR_TS3 = 2
+    SENSOR_TS4 = 3
+
+
+class Stm32PortFinder:
+    @overload
+    def FindMatchingComPorts(vid: UInt32, pid: UInt32) -> List: ...
+    @overload
+    def FindMatchingComPorts(vid: str, pid: str) -> List: ...
+
+
+class StructureConversion:
+    def ConvertConfigV1ToV2(configV1: DeviceConfigStructV1) -> DeviceConfigStructV2: ...
+    def ConvertConfigV1ToV3(configV1: DeviceConfigStructV1) -> DeviceConfigStructV3: ...
+    def ConvertConfigV2ToV1(configV2: DeviceConfigStructV2) -> DeviceConfigStructV1: ...
+    def ConvertConfigV2ToV3(configV2: DeviceConfigStructV2) -> DeviceConfigStructV3: ...
+    def ConvertConfigV3ToV1(configV3: DeviceConfigStructV3) -> DeviceConfigStructV1: ...
+    def ConvertConfigV3ToV2(configV3: DeviceConfigStructV3) -> DeviceConfigStructV2: ...
+
+
+class TempSource(int):
+    TempSourceTsIn = 0
+    TempSourceTsOut = 1
+    TempSourceTs1 = 2
+    TempSourceTs2 = 3
+    TempSourceTmax = 4
+
+
+class Theme(int):
+    ThemeTg1 = 0
+    ThemeTg2 = 1
+    ThemeTg3 = 2
+
+
+class THEME_BACKGROUND(int):
+    ThermalGrizzlyOrange = 1
+    ThermalGrizzlyDark = 2
+    Disabled = 255
+
+
+class THEME_FAN(int):
+    ThermalGrizzlyOrange = 100
+    ThermalGrizzlyDark = 117
+    ThermalGrizzlyBlackWhite = 152
+
+
+class TimeoutMode(int):
+    TimeoutModeStatic = 0
+    TimeoutModeCycle = 1
+    TimeoutModeSleep = 2
+
+
+class UiConfigStructV1:
+    pass
+
+
+class UiConfigStructV2:
+    pass
+
+
+class UsbCmd(int):
+    CMD_WELCOME = 0
+    CMD_READ_VENDOR_DATA = 1
+    CMD_READ_UID = 2
+    CMD_READ_DEVICE_DATA = 3
+    CMD_READ_SENSOR_VALUES = 4
+    CMD_READ_CONFIG = 5
+    CMD_WRITE_CONFIG = 6
+    CMD_READ_CALIBRATION = 7
+    CMD_WRITE_CALIBRATION = 8
+    CMD_SPI_FLASH_WRITE_PAGE = 9
+    CMD_SPI_FLASH_READ_PAGE = 10
+    CMD_SPI_FLASH_ERASE_SECTOR = 11
+    CMD_SCREEN_CHANGE = 12
+    CMD_READ_BUILD_INFO = 13
+    CMD_CLEAR_FAULTS = 14
+    CMD_RESET = 240
+    CMD_BOOTLOADER = 241
+    CMD_NVM_CONFIG = 242
+    CMD_NOP = 255
+
+
+class VendorDataStruct:
+    pass

HardwareMonitor/Interop/__init__.py

@@ -0,0 +1,3 @@
+# Generated namespace __init__.py file for 'HardwareMonitor.Interop'
+
+from LibreHardwareMonitor.Interop import *

HardwareMonitor/PawnIo/__init__.py

@@ -0,0 +1,3 @@
+# Generated namespace __init__.py file for 'HardwareMonitor.PawnIo'
+
+from LibreHardwareMonitor.PawnIo import *

HardwareMonitor/PawnIo/__init__.pyi

@@ -0,0 +1,109 @@
+from HardwareMonitor._util.types import Byte, Int64, UInt32, UInt64
+from typing import Set, Tuple, overload
+
+
+class AmdFamily0F:
+    def __init__(self): ...
+    def Close(self) -> None: ...
+    def GetThermtrip(self, cpuIndex: int, coreIndex: UInt32) -> UInt32: ...
+    @overload
+    def ReadMsr(self, index: UInt32) -> Tuple[bool, UInt32, UInt32]: ...
+    @overload
+    def ReadMsr(self, index: UInt32, affinity: GroupAffinity) -> Tuple[bool, UInt32, UInt32]: ...
+
+
+class AmdFamily10:
+    def __init__(self): ...
+    def Close(self) -> None: ...
+    def HaveCstateResidencyInfo(self) -> bool: ...
+    def MeasureTscMultiplier(self) -> Tuple[Int64, Int64]: ...
+    def ReadCstateResidency(self) -> Set[Byte]: ...
+    def ReadMiscCtl(self, cpu: int, offset: UInt32) -> UInt32: ...
+    @overload
+    def ReadMsr(self, index: UInt32) -> Tuple[bool, UInt32, UInt32]: ...
+    @overload
+    def ReadMsr(self, index: UInt32, affinity: GroupAffinity) -> Tuple[bool, UInt32, UInt32]: ...
+    def ReadSmu(self, offset: UInt32) -> UInt32: ...
+
+
+class AmdFamily17:
+    def __init__(self): ...
+    def Close(self) -> None: ...
+    @overload
+    def ReadMsr(self, index: UInt32) -> Tuple[bool, UInt64]: ...
+    @overload
+    def ReadMsr(self, index: UInt32) -> Tuple[bool, UInt32, UInt32]: ...
+    def ReadSmn(self, offset: UInt32) -> UInt32: ...
+
+
+class IntelMsr:
+    def __init__(self): ...
+    def Close(self) -> None: ...
+    @overload
+    def ReadMsr(self, index: UInt32) -> Tuple[bool, UInt64]: ...
+    @overload
+    def ReadMsr(self, index: UInt32) -> Tuple[bool, UInt32, UInt32]: ...
+    @overload
+    def ReadMsr(self, index: UInt32, affinity: GroupAffinity) -> Tuple[bool, UInt32, UInt32]: ...
+
+
+class IsaBridgeEc:
+    def __init__(self): ...
+    def Close(self) -> None: ...
+    def FindSuperIoMMIO(self) -> Tuple[bool, MMIOMapping, MMIOMapping]: ...
+    def GetOriginalState(self) -> Tuple[bool, MMIOState]: ...
+    def Map(self) -> bool: ...
+    def ReadMmio(self, superIoIndex: Int64, offset: Int64, size: Int64) -> Tuple[bool, Byte]: ...
+    def TryGetCurrentState(self) -> Tuple[bool, MMIOState]: ...
+    def TrySetState(self, state: MMIOState) -> bool: ...
+    def Unmap(self) -> bool: ...
+    def WriteMmio(self, superIoIndex: Int64, offset: Int64, size: Int64, value: Byte) -> bool: ...
+
+
+class LpcAcpiEc:
+    def __init__(self): ...
+    def Close(self) -> None: ...
+    def ReadPort(self, port: Byte) -> Byte: ...
+    def WritePort(self, port: Byte, value: Byte) -> None: ...
+
+
+class LpcCrOSEc:
+    def __init__(self): ...
+    def Close(self) -> None: ...
+    def EcCommand(self, version: int, command: int, outsize: int, insize: int, data: Set[Byte]) -> Set[Byte]: ...
+    def ReadMemmap(self, offset: Byte, bytes: Byte) -> Set[Byte]: ...
+
+
+class MMIOMapping:
+    pass
+
+
+class MMIOState(int):
+    MMIO_Disabled = 0
+    MMIO_Enabled2E = 1
+    MMIO_Enabled4E = 2
+    MMIO_EnabledBoth = 3
+    Unknown = -999
+    MMIO_Original = -1
+
+
+class PawnIo:
+    def Close(self) -> None: ...
+    def Execute(self, name: str, input: Set[Int64], outLength: int) -> Set[Int64]: ...
+    def ExecuteHr(self, name: str, inBuffer: Set[Int64], inSize: UInt32, outBuffer: Set[Int64], outSize: UInt32) -> Tuple[int, UInt32]: ...
+    @property
+    def IsInstalled() -> bool: ...
+    @property
+    def IsLoaded(self) -> bool: ...
+    @property
+    def Version() -> Version: ...
+
+
+class RyzenSmu:
+    def __init__(self): ...
+    def Close(self) -> None: ...
+    def GetCodeName(self) -> Int64: ...
+    def GetSmuVersion(self) -> UInt32: ...
+    def ReadPmTable(self, size: int) -> Set[Int64]: ...
+    def ResolvePmTable(self) -> Tuple[UInt32, UInt32]: ...
+    def UpdatePmTable(self) -> None: ...

HardwareMonitor/Software/__init__.py

@@ -0,0 +1,3 @@
+# Generated namespace __init__.py file for 'HardwareMonitor.Software'
+
+from LibreHardwareMonitor.Software import *

HardwareMonitor/Software/__init__.pyi

@@ -0,0 +1,9 @@
+
+
+class OperatingSystem:
+    @property
+    def Is64Bit() -> bool: ...
+    @property
+    def IsUnix() -> bool: ...
+    @property
+    def IsWindows8OrGreater() -> bool: ...

HardwareMonitor/Util.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import logging
+from typing import Dict, Iterable, List, TypeAlias, cast
+
+from System.Collections.Generic import IDictionary, IList
+
+import HardwareMonitor
+from HardwareMonitor._util.types import Nullable
+from HardwareMonitor.Hardware import Computer, Hardware, HardwareType, IParameter, ISensor, IVisitor, SensorType
+
+logger = logging.getLogger("PyHardwareMonitor")
+
+# ------------------------------------------------------------------------------
+def _get_name_to_type(obj):
+    def object_getattr(attr):
+        try:    return getattr(obj, attr)
+        except: pass
+    result = {}
+    for (a, v) in zip(dir(obj), map(object_getattr, dir(obj))):
+        if type(v) in (int, obj):
+            result[v] = result[int(v)] = a
+    return result
+
+HardwareTypeString: Dict[HardwareType|int, str] = _get_name_to_type(HardwareType)
+SensorTypeString:   Dict[SensorType  |int, str] = _get_name_to_type(SensorType)
+
+SensorTypeUnitFormatter = {
+    SensorType.Voltage: "{:.3f} V",
+    SensorType.Current: "{:.3f} A",
+    SensorType.Clock: "{:.1f} MHz",
+    SensorType.Load: "{:.1f} %",
+    SensorType.Temperature: "{:.1f} °C",
+    SensorType.Fan: "{:.0f} RPM",
+    SensorType.Flow: "{:.1f} L/h",
+    SensorType.Control: "{:.1f} %",
+    SensorType.Level: "{:.1f} %",
+    SensorType.Power: "{:.1f} W",
+    SensorType.Data: "{:.1f} GB",
+    SensorType.SmallData: "{:.1f} MB",
+    SensorType.Factor: "{:.3f}",
+    SensorType.Frequency: "{:.1f} Hz",
+    SensorType.Throughput: "{:.1f} B/s",
+    SensorType.TimeSpan: "{}",
+    SensorType.Energy: "{:.0f} mWh",
+}
+
+SensorType_t: TypeAlias = int
+
+def SensorValueToString(value: float|Nullable, type: SensorType_t) -> str:
+    return SensorTypeUnitFormatter.get(type, "{}").format(isinstance(value, float) and value or 0)
+
+
+def GroupSensorsByType(sensors: Iterable[ISensor]) -> List[List[ISensor]]:
+    groups = {}
+    for sensor in sensors:
+        group = groups[sensor.SensorType] = groups.get(sensor.SensorType, [])
+        group.append(sensor)
+    return list(groups.values())
+
+
+# ------------------------------------------------------------------------------
+_generic_type_cache = {}
+
+
+def IsInstanceOfInterface(obj, interface):
+    if not hasattr(obj, "GetType"):
+        return False
+    try:
+        obj_type = obj.GetType()
+        if obj_type in _generic_type_cache:
+            return any(cmp == interface for cmp in _generic_type_cache[obj_type])
+        ifaces = list(i for i in obj.GetType().GetInterfaces() if i.IsGenericType)
+        cache  = _generic_type_cache[obj_type] = set()
+        for iface in ifaces:
+            cache.add(iface.GetGenericTypeDefinition())
+        return any(cmp == interface for cmp in cache)
+    except:
+        pass
+    return False
+
+
+# ------------------------------------------------------------------------------
+_UPDATE_WARNING_CACHE = set()
+def UpdateHardwareSafe(hardware: Hardware):
+    try:
+        hardware.Update()
+    except:
+        if hardware.Identifier not in _UPDATE_WARNING_CACHE:
+            logger.warning(f"Unable to update HardwareMonitor sensors for {hardware.Identifier} ('{hardware.Name}')")
+            _UPDATE_WARNING_CACHE.add(hardware.Identifier)
+
+
+# ------------------------------------------------------------------------------
+class UpdateVisitor(IVisitor):
+    __namespace__ = "HardwareMonitor.Util"
+    def __init__(self, time_window=1.0):
+        super().__init__()
+        self.time_window = time_window
+
+    def VisitComputer(self, computer: Computer):
+        computer.Traverse(self)
+
+    def VisitHardware(self, hardware: Hardware):
+        UpdateHardwareSafe(hardware)
+        for subHardware in hardware.SubHardware:
+            UpdateHardwareSafe(cast(Hardware, subHardware))
+
+    def VisitParameter(self, parameter: IParameter):
+        pass
+
+    def VisitSensor(self, sensor: ISensor):
+        sensor.ValuesTimeWindow = self.time_window  # type: ignore
+
+
+# ------------------------------------------------------------------------------
+class PyComputer(Computer):
+    def __init__(self, time_window=1.0, **settings):
+        def attr_filter(attr):
+            return attr.startswith("Is") and attr.endswith("Enabled")
+
+        super().__init__()
+        for attr in filter(attr_filter, dir(self)):
+            key = attr[2:-7].lower()
+            setattr(self, attr, bool(settings.get(key, settings.get("all", False))))
+        self._visitor = UpdateVisitor(time_window)
+
+    def Update(self):
+        self.Open()
+        self.Accept(self._visitor)
+        return self
+
+    def __enter__(self):
+        self.Open()
+        self.Accept(self._visitor)
+        return self
+
+    def __exit__(self, *args):
+        self.Close()
+
+    def __del__(self):
+        try:    self.Close()
+        except: pass
+
+
+# ------------------------------------------------------------------------------
+def OpenComputer(**settings) -> PyComputer:
+    computer = PyComputer(**settings)
+    return computer.Update()
+
+
+# ------------------------------------------------------------------------------
+def ToBuiltinTypes(obj, exclude=["Parameters", "Values"]):
+    def process_object(obj):
+        # Return 'primitive' python types as such
+        if type(obj) in (str, bytes, bool, int, float):
+            return obj
+        elif type(obj) in (list, tuple, set):
+            return list(map(process_object, obj))
+        elif type(obj) in (dict,):
+                return dict((k, process_object(v)) for k,v in obj.items())
+        # Handle .NET objects
+        if hasattr(obj, "GetType"):
+            # Return enums as the string representation of the value
+            if obj.GetType().IsEnum:
+                return obj.ToString()
+            # Prevent recursion within HardwareMonitor objects
+            if obj in visited:
+                return None
+            visited.add(obj)
+            # Convert lists and dictionaries to python objects
+            if obj.GetType().IsArray or IsInstanceOfInterface(obj, IList):
+                return list(map(process_object, obj))
+            if IsInstanceOfInterface(obj, IDictionary):
+                return dict((k, process_object(obj.get_Item(k))) for k in list(obj))
+            # Handle objects from the 'HardwareMonitor.Hardware' namespace
+            if obj.__class__.__module__.startswith(HardwareMonitor.ASSEMBLY_NAME):
+                cls_name = obj.__class__.__name__
+                if cls_name[:2].isupper() and cls_name[0] == "I":
+                    cls_name = cls_name[1:]
+                obj_dict = {}
+                # Iterate over all "public" members of the object
+                for attr in [a for a in dir(obj) if not a.startswith("_")]:
+                    if attr in exclude or attr.startswith("IsDefault"):
+                        continue
+                    val = getattr(obj, attr)
+                    val_reduced = process_object(val)
+                    if val_reduced is None or val_reduced == [None]:
+                        continue
+                    elif val_reduced or type(val_reduced) is not dict:
+                        obj_dict[attr] = val_reduced
+                if not obj_dict:
+                    return None
+                # Add the class name to allow for easy filtering
+                result = {"Type": cls_name}
+                result.update(obj_dict)
+                return result
+        return None
+    visited = set()
+    return process_object(obj)

HardwareMonitor/__init__.py

@@ -0,0 +1,51 @@
+
+import sys
+import clr
+import ctypes
+import logging
+import struct
+import platform as _platform
+from   pathlib import Path
+
+
+logger = logging.getLogger("PyHardwareMonitor")
+
+
+def _checkForPawnIO():
+    """
+    Detect if the PawnIO module is installed by searching for uninstall entry in the registry.
+    """
+    import winreg
+    key_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\PawnIO"
+    try:
+        access_flags = winreg.KEY_READ
+        if sys.maxsize < 2**32:
+            access_flags |= winreg.KEY_WOW64_64KEY
+        with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path, 0, access_flags):
+            return True
+    except:
+        pass
+    return False
+
+
+if not ctypes.windll.shell32.IsUserAnAdmin():
+    logger.warning("Admin privileges are required for 'HardwareMonitor' to work properly.")
+
+if not _checkForPawnIO():
+    logger.warning("""PawnIO is not installed - Many sensor will not be available.
+    Please install manually through one of the following methods:
+        1) Run the terminal command 'winget install PawnIO'
+        2) Download and run 'https://github.com/namazso/PawnIO.Setup/releases/latest/download/PawnIO_setup.exe'
+""")
+
+
+ASSEMBLY_NAME = "LibreHardwareMonitor"
+
+_machine = _platform.machine().lower()
+_arch = "ARM64" if _machine == "arm64" else ("x64" if struct.calcsize("P") == 8 else "x86")
+_arch_lib = Path(__file__).parent.joinpath("lib", _arch)
+_LIB_PATH = (_arch_lib if _arch_lib.is_dir() else Path(__file__).parent.joinpath("lib")).absolute()
+sys.path.insert(0, str(_LIB_PATH))
+__reference__ = clr.AddReference(str(_LIB_PATH / (ASSEMBLY_NAME + "Lib.dll")))
+
+__import__(ASSEMBLY_NAME)