Das deutsche Python-Forum

Code: Alles auswählen

import os

# Activate the virtual environment
activate_script = os.path.join('myenv','bin','activate')
print(f"source {activate_script}")
import psutil
import GPUtil

print("Virtuelle Umgebung gestartet")
def get_system_data():
    # Get CPU usage
    cpu_usage = psutil.cpu_percent(interval=1)

    # Get RAM usage
    ram = psutil.virtual_memory()
    ram_usage = ram.percent

    # Get GPU data
    gpus = GPUtil.getGPUs()
    gpu_data = []
    for gpu in gpus:
        gpu_data.append({
            'id': gpu.id,
            'name': gpu.name,
            'load': gpu.load * 100,
            'memoryTotal': gpu.memoryTotal,
            'memoryUsed': gpu.memoryUsed,
            'memoryFree': gpu.memoryFree,
            'temperature': gpu.temperature,
            'uuid': gpu.uuid
        })

    return {
        'cpu_usage': cpu_usage,
        'ram_usage': ram_usage,
        'gpu_data': gpu_data
    }



if __name__ == "__main__":
    system_data = get_system_data()
    print(f"System Data: {system_data}")

Code: Alles auswählen

import time
import requests
import paramiko

def execute_remote_script(hostname, port, username, password, script_path):
    try:
        # Verbindung zum Remote-Server herstellen
        client = paramiko.SSHClient()
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        client.connect(hostname, port=port, username=username, password=password)

        # Skript auf dem Remote-Server ausführen
        stdin, stdout, stderr = client.exec_command(f'python3 {script_path}')
        output = stdout.read().decode()
        error = stderr.read().decode()

        # Verbindung schließen
        client.close()

        if error:
            print(f"Fehler beim Ausführen des Skripts: {error}")
            return None
        return output
    except Exception as e:
        print(f"Fehler bei der Verbindung zum Remote-Server: {e}")
        return None

# Remote-Server-Details
REMOTE_HOSTNAME = ""
REMOTE_PORT = 
REMOTE_USERNAME = ""
REMOTE_PASSWORD = ""
REMOTE_SCRIPT_PATH = "/mnt/usb/Daten_auslesen.py"

# OpenWebUI API-Details
OPENWEBUI_API_URL = "http://"
OPENWEBUI_API_KEY = "mein key"

def measure_latency_and_response_time(api_url, payload):
    start_time = time.time()
    try:
        response = requests.post(api_url, json=payload, timeout=60)  # Timeout auf 30 Sekunden erhöhen
    except requests.exceptions.RequestException as e:
        print(f"Fehler bei der API-Anfrage: {e}")
        return None, None, None
    end_time = time.time()
    
    latency = end_time - start_time
    response_time = response.elapsed.total_seconds()
    
    return latency, response_time, response.json()

def main():
    payload = {
        "model": "llama:8b",
        "prompt": "1+1"
    }
    
    # Remote-Skript auf dem Server ausführen
    remote_script_output = execute_remote_script(REMOTE_HOSTNAME, REMOTE_PORT, REMOTE_USERNAME, REMOTE_PASSWORD, REMOTE_SCRIPT_PATH)
    
    if remote_script_output is None:
        print("Fehler beim Ausführen des Remote-Skripts. Überprüfe die Verbindung und das Skript.")
        return
    
    print(f"Ausgabe des Remote-Skripts: {remote_script_output}")
    
    # Messen der Latenzzeit und Antwortzeit
    latency, response_time, result = measure_latency_and_response_time(OPENWEBUI_API_URL, payload)
    
    if latency is None or response_time is None or result is None:
        print("Fehler bei der API-Anfrage. Überprüfe die Verbindung und die API-URL.")
        return
    
    # Ausgabe der Ergebnisse
    print(f"Latenzzeit: {latency} Sekunden")
    print(f"Antwortzeit: {response_time} Sekunden")
    print(f"API-Antwort: {result}")

if __name__ == "__main__":
    main()

Code: Alles auswählen

import socket
from getpass import getpass
from pathlib import Path

from paramiko import AutoAddPolicy, SSHClient
from paramiko.ssh_exception import AuthenticationException, NoValidConnectionsError


def execute_remote_script(hostname, port, username, password, python_venv, script_path):
    with SSHClient() as client:
        client.set_missing_host_key_policy(AutoAddPolicy())
        client.connect(hostname, port=port, username=username, password=password)

        _, stdout, stderr = client.exec_command(f"{python_venv} {script_path}")
        output = stdout.read().decode()
        error = stderr.read().decode()

    if error:
        raise RuntimeError(f"Fehler beim Ausführen des Skripts: {error}")

    return output


try:
    output = execute_remote_script(
        "archive.server101.icu",
        22,
        "public",
        getpass("Passwort: "),
        "/home/public/.pyenv/versions/3.12.5/bin/python",
        "test.py",
    )
except socket.gaierror:
    print("Kann DNS nicht auflösen.")
except NoValidConnectionsError:
    print("Kann SSH-Verbindung nicht aufbauen.")
except AuthenticationException:
    print("Authentifizierung fehlgeschlagen. Passwort richtig?")
except RuntimeError as e:
    print(e.args[0])
else:
    print(output)

Code: Alles auswählen

import GPUtil
import psutil


def get_system_data():
    return {
        "cpu_usage": psutil.cpu_percent(interval=1),
        "ram_usage": psutil.virtual_memory().percent,
        "gpu_data": [
            {
                "id": gpu.id,
                "name": gpu.name,
                "load": gpu.load * 100,
                "memoryTotal": gpu.memoryTotal,
                "memoryUsed": gpu.memoryUsed,
                "memoryFree": gpu.memoryFree,
                "temperature": gpu.temperature,
                "uuid": gpu.uuid,
            }
            for gpu in GPUtil.getGPUs()
        ],
    }


if __name__ == "__main__":
    print(f"System Data: {get_system_data()}")