initial commit
This commit is contained in:
35
output/Pc-monitor/_internal/plugins/__init__.py
Normal file
35
output/Pc-monitor/_internal/plugins/__init__.py
Normal file
@@ -0,0 +1,35 @@
|
||||
# Plugins pour PC Monitor
|
||||
from .base import BasePlugin
|
||||
from .librehardwaremonitor import LibreHardwareMonitorPlugin
|
||||
from .hwinfo import HWiNFOPlugin
|
||||
|
||||
# Registry des plugins disponibles
|
||||
PLUGINS = {
|
||||
'librehardwaremonitor': LibreHardwareMonitorPlugin,
|
||||
'hwinfo': HWiNFOPlugin
|
||||
}
|
||||
|
||||
def get_plugin(name: str, config: dict) -> BasePlugin:
|
||||
"""Retourne une instance du plugin demandé"""
|
||||
if name not in PLUGINS:
|
||||
raise ValueError(f"Plugin inconnu: {name}")
|
||||
return PLUGINS[name](config)
|
||||
|
||||
def get_available_plugins() -> list:
|
||||
"""Retourne la liste des plugins disponibles"""
|
||||
return [
|
||||
{
|
||||
'id': 'librehardwaremonitor',
|
||||
'name': 'LibreHardwareMonitor',
|
||||
'description': 'Open source, API REST intégrée',
|
||||
'default_port': 8085,
|
||||
'website': 'https://github.com/LibreHardwareMonitor/LibreHardwareMonitor'
|
||||
},
|
||||
{
|
||||
'id': 'hwinfo',
|
||||
'name': 'HWiNFO + RemoteHWInfo',
|
||||
'description': 'HWiNFO avec RemoteHWInfo (github.com/Demion/remotehwinfo)',
|
||||
'default_port': 60000,
|
||||
'website': 'https://github.com/Demion/remotehwinfo'
|
||||
}
|
||||
]
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
151
output/Pc-monitor/_internal/plugins/base.py
Normal file
151
output/Pc-monitor/_internal/plugins/base.py
Normal file
@@ -0,0 +1,151 @@
|
||||
"""
|
||||
Classe de base pour tous les plugins de monitoring
|
||||
"""
|
||||
from abc import ABC, abstractmethod
|
||||
from typing import Optional, List, Dict, Any
|
||||
|
||||
|
||||
class BasePlugin(ABC):
|
||||
"""Classe abstraite définissant l'interface des plugins"""
|
||||
|
||||
def __init__(self, config: dict):
|
||||
"""
|
||||
Initialise le plugin avec sa configuration
|
||||
|
||||
Args:
|
||||
config: Configuration du plugin (host, port, etc.)
|
||||
"""
|
||||
self.host = config.get('host', '127.0.0.1')
|
||||
self.port = config.get('port', self.get_default_port())
|
||||
self.config = config
|
||||
|
||||
@abstractmethod
|
||||
def get_id(self) -> str:
|
||||
"""Retourne l'identifiant unique du plugin"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def get_name(self) -> str:
|
||||
"""Retourne le nom affichable du plugin"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def get_default_port(self) -> int:
|
||||
"""Retourne le port par défaut"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def test_connection(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Teste la connexion au logiciel de monitoring
|
||||
|
||||
Returns:
|
||||
dict avec 'success' (bool), 'message' (str), et optionnellement 'version'
|
||||
"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def get_data(self) -> Optional[dict]:
|
||||
"""
|
||||
Récupère les données brutes du logiciel de monitoring
|
||||
|
||||
Returns:
|
||||
Données brutes ou None si erreur
|
||||
"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def get_hierarchy(self) -> List[dict]:
|
||||
"""
|
||||
Récupère la hiérarchie des capteurs (pour l'admin)
|
||||
|
||||
Returns:
|
||||
Liste de hardware avec leurs capteurs
|
||||
"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def parse_sensors(self, data: dict) -> List[dict]:
|
||||
"""
|
||||
Parse les données brutes en liste standardisée de capteurs
|
||||
|
||||
Args:
|
||||
data: Données brutes du logiciel
|
||||
|
||||
Returns:
|
||||
Liste de capteurs au format standardisé:
|
||||
[
|
||||
{
|
||||
'id': str, # Identifiant unique
|
||||
'name': str, # Nom du capteur
|
||||
'value': str, # Valeur formatée (ex: "45 °C")
|
||||
'raw_value': float, # Valeur numérique
|
||||
'type': str, # Type (temperature, load, voltage, etc.)
|
||||
'unit': str, # Unité (°C, %, MHz, etc.)
|
||||
'hardware': str, # Nom du hardware parent
|
||||
'hardware_type': str # Type de hardware (CPU, GPU, etc.)
|
||||
},
|
||||
...
|
||||
]
|
||||
"""
|
||||
pass
|
||||
|
||||
def get_base_url(self) -> str:
|
||||
"""Retourne l'URL de base pour les requêtes"""
|
||||
return f"http://{self.host}:{self.port}"
|
||||
|
||||
def get_sensor_type(self, unit: str, name: str = '') -> str:
|
||||
"""
|
||||
Détermine le type de capteur à partir de l'unité et du nom
|
||||
|
||||
Args:
|
||||
unit: Unité du capteur
|
||||
name: Nom du capteur (pour affiner la détection)
|
||||
|
||||
Returns:
|
||||
Type standardisé du capteur
|
||||
"""
|
||||
unit_lower = unit.lower() if unit else ''
|
||||
name_lower = name.lower() if name else ''
|
||||
|
||||
# Détection par unité
|
||||
if '°c' in unit_lower or '°f' in unit_lower:
|
||||
return 'temperature'
|
||||
elif '%' in unit_lower:
|
||||
if 'load' in name_lower or 'usage' in name_lower:
|
||||
return 'load'
|
||||
return 'percentage'
|
||||
elif 'mhz' in unit_lower or 'ghz' in unit_lower:
|
||||
return 'frequency'
|
||||
elif 'rpm' in unit_lower:
|
||||
return 'fan'
|
||||
elif 'w' in unit_lower and 'wh' not in unit_lower:
|
||||
return 'power'
|
||||
elif 'v' in unit_lower and 'mv' not in unit_lower:
|
||||
return 'voltage'
|
||||
elif 'mv' in unit_lower:
|
||||
return 'voltage'
|
||||
elif 'mb' in unit_lower or 'gb' in unit_lower or 'kb' in unit_lower:
|
||||
return 'data'
|
||||
elif 'mb/s' in unit_lower or 'kb/s' in unit_lower or 'gb/s' in unit_lower:
|
||||
return 'throughput'
|
||||
elif 'a' in unit_lower:
|
||||
return 'current'
|
||||
elif 'wh' in unit_lower:
|
||||
return 'energy'
|
||||
|
||||
# Détection par nom si unité non reconnue
|
||||
if 'temp' in name_lower or 'temperature' in name_lower:
|
||||
return 'temperature'
|
||||
elif 'fan' in name_lower:
|
||||
return 'fan'
|
||||
elif 'clock' in name_lower or 'freq' in name_lower:
|
||||
return 'frequency'
|
||||
elif 'load' in name_lower or 'usage' in name_lower:
|
||||
return 'load'
|
||||
elif 'power' in name_lower:
|
||||
return 'power'
|
||||
elif 'voltage' in name_lower or 'vcore' in name_lower:
|
||||
return 'voltage'
|
||||
|
||||
return 'generic'
|
||||
274
output/Pc-monitor/_internal/plugins/hwinfo.py
Normal file
274
output/Pc-monitor/_internal/plugins/hwinfo.py
Normal file
@@ -0,0 +1,274 @@
|
||||
"""
|
||||
Plugin pour HWiNFO via RemoteHWInfo (Demion)
|
||||
https://github.com/Demion/remotehwinfo
|
||||
|
||||
Format JSON RemoteHWInfo:
|
||||
{
|
||||
"hwinfo": {
|
||||
"sensors": [
|
||||
{"entryIndex": 0, "sensorNameUser": "System", ...},
|
||||
{"entryIndex": 1, "sensorNameUser": "CPU [#0]: Intel Core i7", ...}
|
||||
],
|
||||
"readings": [
|
||||
{"sensorIndex": 0, "labelUser": "Memory Load", "value": 45.5, "unit": "%", ...},
|
||||
{"sensorIndex": 1, "labelUser": "CPU Temp", "value": 65.0, "unit": "°C", ...}
|
||||
]
|
||||
}
|
||||
}
|
||||
"""
|
||||
import requests
|
||||
from typing import Dict, List, Optional, Any
|
||||
from .base import BasePlugin
|
||||
|
||||
|
||||
class HWiNFOPlugin(BasePlugin):
|
||||
"""Plugin pour HWiNFO via RemoteHWInfo"""
|
||||
|
||||
def __init__(self, config: dict):
|
||||
super().__init__(config)
|
||||
self.history = {}
|
||||
self.max_history = 120
|
||||
|
||||
def get_id(self) -> str:
|
||||
return 'hwinfo'
|
||||
|
||||
def get_name(self) -> str:
|
||||
return 'HWiNFO'
|
||||
|
||||
def get_default_port(self) -> int:
|
||||
return 60000
|
||||
|
||||
def get_base_url(self) -> str:
|
||||
"""Retourne l'URL de l'API RemoteHWInfo"""
|
||||
return f"http://{self.host}:{self.port}/json.json"
|
||||
|
||||
def test_connection(self) -> Dict[str, Any]:
|
||||
"""Teste la connexion à RemoteHWInfo"""
|
||||
try:
|
||||
url = self.get_base_url()
|
||||
response = requests.get(url, timeout=5)
|
||||
response.raise_for_status()
|
||||
|
||||
data = response.json()
|
||||
|
||||
# Vérifier le format RemoteHWInfo
|
||||
if 'hwinfo' not in data:
|
||||
return {
|
||||
'success': False,
|
||||
'message': 'Format invalide. Vérifiez que RemoteHWInfo est lancé.'
|
||||
}
|
||||
|
||||
hwinfo = data['hwinfo']
|
||||
sensor_count = len(hwinfo.get('sensors', []))
|
||||
reading_count = len(hwinfo.get('readings', []))
|
||||
|
||||
return {
|
||||
'success': True,
|
||||
'message': f'Connecté - {sensor_count} capteurs, {reading_count} lectures',
|
||||
'version': 'RemoteHWInfo',
|
||||
'sensor_count': reading_count
|
||||
}
|
||||
|
||||
except requests.exceptions.ConnectionError:
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Impossible de se connecter à {self.get_base_url()}. Vérifiez que RemoteHWInfo est lancé.'
|
||||
}
|
||||
except requests.exceptions.Timeout:
|
||||
return {
|
||||
'success': False,
|
||||
'message': 'Timeout - Le serveur ne répond pas'
|
||||
}
|
||||
except Exception as e:
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Erreur: {str(e)}'
|
||||
}
|
||||
|
||||
def get_data(self) -> Optional[Dict]:
|
||||
"""Récupère les données JSON depuis RemoteHWInfo"""
|
||||
try:
|
||||
url = self.get_base_url()
|
||||
response = requests.get(url, timeout=5)
|
||||
response.raise_for_status()
|
||||
|
||||
data = response.json()
|
||||
|
||||
if 'hwinfo' in data:
|
||||
return data['hwinfo']
|
||||
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
print(f"Erreur HWiNFO get_data: {e}")
|
||||
return None
|
||||
|
||||
def get_hierarchy(self) -> List[dict]:
|
||||
"""Récupère la hiérarchie des capteurs pour l'admin"""
|
||||
data = self.get_data()
|
||||
if not data:
|
||||
return []
|
||||
|
||||
return self._build_hierarchy(data)
|
||||
|
||||
def _build_hierarchy(self, data: Dict) -> List[dict]:
|
||||
"""Construit la hiérarchie des capteurs"""
|
||||
sensors = data.get('sensors', [])
|
||||
readings = data.get('readings', [])
|
||||
|
||||
# Créer un dictionnaire des sensors par index
|
||||
sensor_map = {}
|
||||
for sensor in sensors:
|
||||
idx = sensor.get('entryIndex', 0)
|
||||
sensor_map[idx] = {
|
||||
'name': sensor.get('sensorNameUser', sensor.get('sensorNameOriginal', 'Unknown')),
|
||||
'value': '',
|
||||
'id': '',
|
||||
'level': 0,
|
||||
'type': 'group',
|
||||
'children': []
|
||||
}
|
||||
|
||||
# Ajouter les readings aux sensors correspondants
|
||||
for reading in readings:
|
||||
sensor_idx = reading.get('sensorIndex', 0)
|
||||
|
||||
if sensor_idx not in sensor_map:
|
||||
continue
|
||||
|
||||
label = reading.get('labelUser', reading.get('labelOriginal', 'Unknown'))
|
||||
value = reading.get('value', 0)
|
||||
unit = reading.get('unit', '')
|
||||
|
||||
# Générer un ID unique
|
||||
sensor_id = self._generate_sensor_id(sensor_idx, reading.get('readingId', 0), label)
|
||||
|
||||
# Formater la valeur
|
||||
if isinstance(value, float):
|
||||
if value == int(value):
|
||||
formatted_value = f"{int(value)} {unit}".strip()
|
||||
else:
|
||||
formatted_value = f"{value:.2f} {unit}".strip()
|
||||
else:
|
||||
formatted_value = f"{value} {unit}".strip()
|
||||
|
||||
reading_entry = {
|
||||
'name': label,
|
||||
'value': formatted_value,
|
||||
'id': sensor_id,
|
||||
'level': 1,
|
||||
'type': self.get_sensor_type(unit, label),
|
||||
'children': []
|
||||
}
|
||||
|
||||
sensor_map[sensor_idx]['children'].append(reading_entry)
|
||||
|
||||
# Retourner seulement les sensors qui ont des readings
|
||||
return [s for s in sensor_map.values() if s['children']]
|
||||
|
||||
def parse_sensors(self, data: Dict) -> List[Dict]:
|
||||
"""Parse les données et retourne une liste plate de capteurs"""
|
||||
sensors_list = []
|
||||
|
||||
if not data:
|
||||
return sensors_list
|
||||
|
||||
sensors = data.get('sensors', [])
|
||||
readings = data.get('readings', [])
|
||||
|
||||
# Créer un dictionnaire des sensors par index
|
||||
sensor_names = {}
|
||||
for sensor in sensors:
|
||||
idx = sensor.get('entryIndex', 0)
|
||||
sensor_names[idx] = sensor.get('sensorNameUser', sensor.get('sensorNameOriginal', 'Unknown'))
|
||||
|
||||
# Parser chaque reading
|
||||
for reading in readings:
|
||||
sensor_idx = reading.get('sensorIndex', 0)
|
||||
hardware_name = sensor_names.get(sensor_idx, 'Unknown')
|
||||
|
||||
label = reading.get('labelUser', reading.get('labelOriginal', 'Unknown'))
|
||||
value = reading.get('value', 0)
|
||||
unit = reading.get('unit', '')
|
||||
|
||||
# Générer un ID unique
|
||||
sensor_id = self._generate_sensor_id(sensor_idx, reading.get('readingId', 0), label)
|
||||
|
||||
# Formater la valeur
|
||||
if isinstance(value, float):
|
||||
if value == int(value):
|
||||
formatted_value = f"{int(value)} {unit}".strip()
|
||||
else:
|
||||
formatted_value = f"{value:.2f} {unit}".strip()
|
||||
else:
|
||||
formatted_value = f"{value} {unit}".strip()
|
||||
|
||||
sensor_type = self.get_sensor_type(unit, label)
|
||||
hardware_type = self._guess_hardware_type(hardware_name)
|
||||
|
||||
sensor = {
|
||||
'id': sensor_id,
|
||||
'name': label,
|
||||
'value': formatted_value,
|
||||
'raw_value': float(value) if value else 0.0,
|
||||
'type': sensor_type,
|
||||
'unit': unit,
|
||||
'hardware': hardware_name,
|
||||
'hardware_type': hardware_type,
|
||||
'category': hardware_name,
|
||||
'path': f"{hardware_name}/{label}",
|
||||
}
|
||||
sensors_list.append(sensor)
|
||||
|
||||
return sensors_list
|
||||
|
||||
def _generate_sensor_id(self, sensor_idx: int, reading_id: int, label: str) -> str:
|
||||
"""Génère un ID unique pour un capteur"""
|
||||
# Nettoyer le label pour l'ID
|
||||
clean_label = label.replace(' ', '_').replace('[', '').replace(']', '')
|
||||
clean_label = clean_label.replace('#', '').replace(':', '_').replace('/', '_')
|
||||
return f"/hwinfo/{sensor_idx}_{reading_id}_{clean_label}"
|
||||
|
||||
def _guess_hardware_type(self, sensor_name: str) -> str:
|
||||
"""Devine le type de hardware basé sur le nom du sensor"""
|
||||
name_lower = sensor_name.lower()
|
||||
|
||||
if 'cpu' in name_lower or 'processor' in name_lower:
|
||||
return 'CPU'
|
||||
elif 'gpu' in name_lower or 'graphics' in name_lower or 'radeon' in name_lower or 'geforce' in name_lower:
|
||||
return 'GPU'
|
||||
elif 'memory' in name_lower or 'ram' in name_lower or 'dimm' in name_lower:
|
||||
return 'RAM'
|
||||
elif 'drive' in name_lower or 'disk' in name_lower or 'ssd' in name_lower or 'hdd' in name_lower or 's.m.a.r.t' in name_lower:
|
||||
return 'Storage'
|
||||
elif 'network' in name_lower or 'ethernet' in name_lower or 'wifi' in name_lower or 'réseau' in name_lower:
|
||||
return 'Network'
|
||||
elif 'system' in name_lower or 'système' in name_lower:
|
||||
return 'System'
|
||||
else:
|
||||
return 'Other'
|
||||
|
||||
# === Gestion de l'historique ===
|
||||
|
||||
def update_history(self, sensors: List[Dict]):
|
||||
"""Met à jour l'historique des capteurs pour les graphiques"""
|
||||
for sensor in sensors:
|
||||
sensor_id = sensor.get("id", "")
|
||||
if not sensor_id:
|
||||
continue
|
||||
|
||||
raw_value = sensor.get("raw_value", 0.0)
|
||||
|
||||
if sensor_id not in self.history:
|
||||
self.history[sensor_id] = []
|
||||
|
||||
self.history[sensor_id].append(raw_value)
|
||||
|
||||
if len(self.history[sensor_id]) > self.max_history:
|
||||
self.history[sensor_id] = self.history[sensor_id][-self.max_history:]
|
||||
|
||||
def get_history(self, sensor_id: str, count: int = 60) -> List[float]:
|
||||
"""Récupère l'historique d'un capteur"""
|
||||
if sensor_id not in self.history:
|
||||
return []
|
||||
return self.history[sensor_id][-count:]
|
||||
266
output/Pc-monitor/_internal/plugins/librehardwaremonitor.py
Normal file
266
output/Pc-monitor/_internal/plugins/librehardwaremonitor.py
Normal file
@@ -0,0 +1,266 @@
|
||||
"""
|
||||
Plugin pour LibreHardwareMonitor
|
||||
Utilise l'API REST intégrée de LHM (port 8085 par défaut)
|
||||
"""
|
||||
import requests
|
||||
from typing import Dict, List, Optional, Any
|
||||
from .base import BasePlugin
|
||||
|
||||
|
||||
class LibreHardwareMonitorPlugin(BasePlugin):
|
||||
"""Plugin pour LibreHardwareMonitor"""
|
||||
|
||||
def __init__(self, config: dict):
|
||||
super().__init__(config)
|
||||
self.history = {}
|
||||
self.max_history = 120 # 2 minutes à 1 sample/sec
|
||||
|
||||
def get_id(self) -> str:
|
||||
return 'librehardwaremonitor'
|
||||
|
||||
def get_name(self) -> str:
|
||||
return 'LibreHardwareMonitor'
|
||||
|
||||
def get_default_port(self) -> int:
|
||||
return 8085
|
||||
|
||||
def test_connection(self) -> Dict[str, Any]:
|
||||
"""Teste la connexion à LibreHardwareMonitor"""
|
||||
try:
|
||||
url = f"{self.get_base_url()}/data.json"
|
||||
response = requests.get(url, timeout=5)
|
||||
response.raise_for_status()
|
||||
|
||||
data = response.json()
|
||||
|
||||
# Extraire la version si disponible
|
||||
version = "Inconnue"
|
||||
if data and "Text" in data:
|
||||
version = data.get("Text", "LibreHardwareMonitor")
|
||||
|
||||
# Compter les capteurs
|
||||
sensors = self.parse_sensors(data)
|
||||
|
||||
return {
|
||||
'success': True,
|
||||
'message': f'Connecté - {len(sensors)} capteurs détectés',
|
||||
'version': version,
|
||||
'sensor_count': len(sensors)
|
||||
}
|
||||
|
||||
except requests.exceptions.ConnectionError:
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Impossible de se connecter à {self.get_base_url()}. Vérifiez que LibreHardwareMonitor est lancé avec le serveur web activé.'
|
||||
}
|
||||
except requests.exceptions.Timeout:
|
||||
return {
|
||||
'success': False,
|
||||
'message': 'Timeout - Le serveur ne répond pas'
|
||||
}
|
||||
except Exception as e:
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Erreur: {str(e)}'
|
||||
}
|
||||
|
||||
def get_data(self) -> Optional[Dict]:
|
||||
"""Récupère les données JSON depuis LHM Remote Server"""
|
||||
try:
|
||||
url = f"{self.get_base_url()}/data.json"
|
||||
response = requests.get(url, timeout=5)
|
||||
response.raise_for_status()
|
||||
return response.json()
|
||||
except Exception as e:
|
||||
print(f"Erreur LHM get_data: {e}")
|
||||
return None
|
||||
|
||||
def get_hierarchy(self) -> List[dict]:
|
||||
"""Récupère la hiérarchie des capteurs pour l'admin"""
|
||||
data = self.get_data()
|
||||
if not data:
|
||||
return []
|
||||
|
||||
return self._build_hierarchy(data)
|
||||
|
||||
def _build_hierarchy(self, data: Dict) -> List[dict]:
|
||||
"""Construit la hiérarchie des capteurs"""
|
||||
if not data or "Children" not in data:
|
||||
return []
|
||||
|
||||
def build_tree(node, level=0):
|
||||
node_text = node.get("Text", "")
|
||||
node_value = node.get("Value", "")
|
||||
sensor_id = node.get("SensorId", "")
|
||||
|
||||
result = {
|
||||
"name": node_text,
|
||||
"value": node_value,
|
||||
"id": sensor_id,
|
||||
"level": level,
|
||||
"type": self._guess_sensor_type(node_text, node_value) if node_value else "group",
|
||||
"children": []
|
||||
}
|
||||
|
||||
if "Children" in node and node["Children"]:
|
||||
for child in node["Children"]:
|
||||
result["children"].append(build_tree(child, level + 1))
|
||||
|
||||
return result
|
||||
|
||||
tree = []
|
||||
for child in data.get("Children", []):
|
||||
tree.append(build_tree(child))
|
||||
|
||||
return tree
|
||||
|
||||
def parse_sensors(self, data: Dict) -> List[Dict]:
|
||||
"""Parse les données et retourne une liste plate de capteurs"""
|
||||
sensors = []
|
||||
|
||||
if not data or "Children" not in data:
|
||||
return sensors
|
||||
|
||||
def extract_sensors(node, parent_name="", hardware_name="", hardware_type=""):
|
||||
node_text = node.get("Text", "")
|
||||
current_path = f"{parent_name}/{node_text}" if parent_name else node_text
|
||||
|
||||
# Détecter le type de hardware au niveau 1
|
||||
if not hardware_name and "Children" in node:
|
||||
hw_type = self._guess_hardware_type(node_text)
|
||||
hardware_name = node_text
|
||||
hardware_type = hw_type
|
||||
|
||||
# Si le nœud a une valeur, c'est un capteur
|
||||
if "Value" in node and node["Value"]:
|
||||
sensor_id = node.get("SensorId", "")
|
||||
if not sensor_id:
|
||||
sensor_id = f"{current_path}".replace(" ", "-").lower()
|
||||
|
||||
value_str = node.get("Value", "")
|
||||
raw_value = self._extract_numeric_value(value_str)
|
||||
unit = self._extract_unit(value_str)
|
||||
sensor_type = self._guess_sensor_type(node_text, value_str)
|
||||
|
||||
sensor = {
|
||||
"id": sensor_id,
|
||||
"name": node_text,
|
||||
"value": value_str,
|
||||
"raw_value": raw_value,
|
||||
"type": sensor_type,
|
||||
"unit": unit,
|
||||
"hardware": hardware_name,
|
||||
"hardware_type": hardware_type,
|
||||
"category": parent_name.split("/")[0] if "/" in parent_name else parent_name,
|
||||
"path": current_path,
|
||||
"min": node.get("Min", ""),
|
||||
"max": node.get("Max", ""),
|
||||
}
|
||||
sensors.append(sensor)
|
||||
|
||||
# Parcourir les enfants récursivement
|
||||
if "Children" in node:
|
||||
for child in node["Children"]:
|
||||
extract_sensors(child, current_path, hardware_name, hardware_type)
|
||||
|
||||
for child in data.get("Children", []):
|
||||
extract_sensors(child)
|
||||
|
||||
return sensors
|
||||
|
||||
def _guess_hardware_type(self, name: str) -> str:
|
||||
"""Devine le type de hardware basé sur le nom"""
|
||||
name_lower = name.lower()
|
||||
|
||||
if 'cpu' in name_lower or 'processor' in name_lower:
|
||||
return 'CPU'
|
||||
elif 'gpu' in name_lower or 'graphics' in name_lower or 'nvidia' in name_lower or 'amd' in name_lower or 'radeon' in name_lower or 'geforce' in name_lower:
|
||||
return 'GPU'
|
||||
elif 'memory' in name_lower or 'ram' in name_lower:
|
||||
return 'RAM'
|
||||
elif 'motherboard' in name_lower or 'mainboard' in name_lower:
|
||||
return 'Motherboard'
|
||||
elif 'storage' in name_lower or 'disk' in name_lower or 'ssd' in name_lower or 'hdd' in name_lower or 'nvme' in name_lower:
|
||||
return 'Storage'
|
||||
elif 'network' in name_lower or 'ethernet' in name_lower or 'wifi' in name_lower:
|
||||
return 'Network'
|
||||
elif 'battery' in name_lower:
|
||||
return 'Battery'
|
||||
else:
|
||||
return 'Other'
|
||||
|
||||
def _guess_sensor_type(self, name: str, value: str) -> str:
|
||||
"""Devine le type de capteur basé sur le nom et la valeur"""
|
||||
name_lower = name.lower()
|
||||
value_lower = value.lower()
|
||||
|
||||
if "°c" in value_lower or "temperature" in name_lower or "temp" in name_lower:
|
||||
return "temperature"
|
||||
elif "%" in value or "load" in name_lower or "usage" in name_lower:
|
||||
return "percentage"
|
||||
elif "rpm" in value_lower or "fan" in name_lower:
|
||||
return "fan"
|
||||
elif "mhz" in value_lower or "ghz" in value_lower or "clock" in name_lower:
|
||||
return "frequency"
|
||||
elif "w" in value_lower and "wh" not in value_lower:
|
||||
return "power"
|
||||
elif "v" in value_lower:
|
||||
return "voltage"
|
||||
elif "gb" in value_lower or "mb" in value_lower or "memory" in name_lower:
|
||||
return "memory"
|
||||
else:
|
||||
return "generic"
|
||||
|
||||
def _extract_numeric_value(self, value_str: str) -> float:
|
||||
"""Extrait la valeur numérique d'une chaîne"""
|
||||
try:
|
||||
# Enlever tous les caractères non numériques sauf le point et la virgule
|
||||
clean = value_str.replace("°C", "").replace("%", "").replace("V", "").replace("W", "")
|
||||
clean = clean.replace("MHz", "").replace("GHz", "").replace("GB", "").replace("MB", "")
|
||||
clean = clean.replace("RPM", "").replace(" ", "").replace(",", ".").strip()
|
||||
|
||||
if clean:
|
||||
return float(clean)
|
||||
except (ValueError, AttributeError):
|
||||
pass
|
||||
return 0.0
|
||||
|
||||
def _extract_unit(self, value_str: str) -> str:
|
||||
"""Extrait l'unité d'une valeur"""
|
||||
value_str = value_str.strip()
|
||||
|
||||
units = ['°C', '°F', '%', 'MHz', 'GHz', 'GB', 'MB', 'KB', 'RPM', 'W', 'V', 'A', 'GB/s', 'MB/s']
|
||||
for unit in units:
|
||||
if unit in value_str:
|
||||
return unit
|
||||
return ''
|
||||
|
||||
# === Gestion de l'historique ===
|
||||
|
||||
def update_history(self, sensors: List[Dict]):
|
||||
"""Met à jour l'historique des capteurs pour les graphiques"""
|
||||
for sensor in sensors:
|
||||
sensor_id = sensor.get("id", "")
|
||||
if not sensor_id:
|
||||
continue
|
||||
|
||||
raw_value = sensor.get("raw_value")
|
||||
if raw_value is None:
|
||||
raw_value = self._extract_numeric_value(sensor.get("value", ""))
|
||||
|
||||
if raw_value == 0.0 and "0" not in sensor.get("value", ""):
|
||||
continue
|
||||
|
||||
if sensor_id not in self.history:
|
||||
self.history[sensor_id] = []
|
||||
|
||||
self.history[sensor_id].append(raw_value)
|
||||
|
||||
if len(self.history[sensor_id]) > self.max_history:
|
||||
self.history[sensor_id] = self.history[sensor_id][-self.max_history:]
|
||||
|
||||
def get_history(self, sensor_id: str, count: int = 60) -> List[float]:
|
||||
"""Récupère l'historique d'un capteur"""
|
||||
if sensor_id not in self.history:
|
||||
return []
|
||||
return self.history[sensor_id][-count:]
|
||||
Reference in New Issue
Block a user