cpu-loader 0.1.3__tar.gz → 0.2.4__tar.gz

{cpu_loader-0.1.3 → cpu_loader-0.2.4}/MANIFEST.in

@@ -2,4 +2,4 @@ include README.md
 include LICENSE
 include pyproject.toml
 include setup.py
-recursive-include src *.py *.c *.h
+recursive-include src *.py *.c *.h *.html

{cpu_loader-0.1.3/src/cpu_loader.egg-info → cpu_loader-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpu-loader
-Version: 0.1.3
+Version: 0.2.4
 Summary: A tool to generate CPU load on a system with runtime configuration through a WebUI and REST API
 Author-email: the78mole <the78mole@users.noreply.github.com>
 License: MIT

{cpu_loader-0.1.3 → cpu_loader-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cpu-loader"
-version = "0.1.3"
+version = "0.2.4"
 description = "A tool to generate CPU load on a system with runtime configuration through a WebUI and REST API"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -52,3 +52,6 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools]
 package-dir = {"" = "src"}
 packages = ["cpu_loader"]
+
+[tool.setuptools.package-data]
+cpu_loader = ["templates/*.html", "*.c"]

cpu_loader-0.2.4/src/cpu_loader/templates/index.html

@@ -0,0 +1,456 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>CPU Loader Control</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            max-width: 900px;
+            margin: 50px auto;
+            padding: 20px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+        }
+        .container {
+            background: white;
+            border-radius: 15px;
+            padding: 30px;
+            box-shadow: 0 10px 40px rgba(0,0,0,0.2);
+        }
+        h1 {
+            color: #333;
+            text-align: center;
+            margin-bottom: 10px;
+        }
+        .subtitle {
+            text-align: center;
+            color: #666;
+            margin-bottom: 30px;
+        }
+        .status {
+            background: #f0f0f0;
+            padding: 15px;
+            border-radius: 8px;
+            margin-bottom: 25px;
+            text-align: center;
+        }
+        .status-item {
+            display: inline-block;
+            margin: 0 15px;
+        }
+        .cpu-metrics {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 10px;
+            margin-bottom: 25px;
+        }
+        .cpu-metrics h3 {
+            margin: 0 0 15px 0;
+            color: #333;
+            font-size: 16px;
+        }
+        .cpu-bar-container {
+            margin-bottom: 12px;
+        }
+        .cpu-bar-label {
+            display: flex;
+            justify-content: space-between;
+            margin-bottom: 5px;
+            font-size: 13px;
+            color: #666;
+        }
+        .cpu-bar-wrapper {
+            background: #e0e0e0;
+            border-radius: 8px;
+            height: 20px;
+            overflow: hidden;
+            position: relative;
+        }
+        .cpu-bar {
+            background: linear-gradient(90deg, #4CAF50 0%, #FFC107 50%, #F44336 100%);
+            height: 100%;
+            transition: width 0.3s ease;
+            border-radius: 8px;
+        }
+        .cpu-bar.total {
+            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        }
+        .preset-buttons {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 30px;
+            flex-wrap: wrap;
+            justify-content: center;
+        }
+        .preset-btn {
+            background: #667eea;
+            color: white;
+            border: none;
+            padding: 12px 20px;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 14px;
+            font-weight: 600;
+            transition: all 0.3s;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        }
+        .preset-btn:hover {
+            background: #5568d3;
+            transform: translateY(-2px);
+            box-shadow: 0 6px 12px rgba(0,0,0,0.15);
+        }
+        .preset-btn:active {
+            transform: translateY(0);
+        }
+        .thread-controls {
+            display: grid;
+            gap: 20px;
+        }
+        .thread-control {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 10px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        }
+        .thread-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 12px;
+        }
+        .thread-label {
+            font-weight: 600;
+            color: #333;
+            font-size: 16px;
+        }
+        .thread-value {
+            background: #667eea;
+            color: white;
+            padding: 4px 12px;
+            border-radius: 15px;
+            font-weight: 600;
+            min-width: 60px;
+            text-align: center;
+        }
+        .slider-container {
+            position: relative;
+        }
+        .slider {
+            width: 100%;
+            height: 8px;
+            border-radius: 5px;
+            background: #ddd;
+            outline: none;
+            -webkit-appearance: none;
+        }
+        .slider::-webkit-slider-thumb {
+            -webkit-appearance: none;
+            appearance: none;
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            background: #667eea;
+            cursor: pointer;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+        }
+        .slider::-moz-range-thumb {
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            background: #667eea;
+            cursor: pointer;
+            border: none;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+        }
+        .slider-labels {
+            display: flex;
+            justify-content: space-between;
+            margin-top: 5px;
+            font-size: 12px;
+            color: #666;
+        }
+        .error {
+            background: #fee;
+            color: #c33;
+            padding: 10px;
+            border-radius: 5px;
+            margin-bottom: 20px;
+            display: none;
+        }
+        .success {
+            background: #efe;
+            color: #3c3;
+            padding: 10px;
+            border-radius: 5px;
+            margin-bottom: 20px;
+            display: none;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>&#x1F525; CPU Loader Control</h1>
+        <p class="subtitle">Control CPU load per thread in real-time</p>
+
+        <div class="status">
+            <div class="status-item">
+                <strong>Active Threads:</strong> <span id="thread-count">-</span>
+            </div>
+            <div class="status-item">
+                <strong>Target Load:</strong> <span id="avg-load">-</span>%
+            </div>
+        </div>
+
+        <div class="cpu-metrics">
+            <h3>📊 Real-Time CPU Usage</h3>
+            <div class="cpu-bar-container">
+                <div class="cpu-bar-label">
+                    <span><strong>Total CPU</strong></span>
+                    <span id="total-cpu-value">-</span>
+                </div>
+                <div class="cpu-bar-wrapper">
+                    <div class="cpu-bar total" id="total-cpu-bar" style="width: 0%"></div>
+                </div>
+            </div>
+            <div id="per-cpu-bars"></div>
+        </div>
+
+        <div class="error" id="error-message"></div>
+        <div class="success" id="success-message"></div>
+
+        <div class="preset-buttons">
+            <button class="preset-btn" onclick="setAllLoads(0)">0%</button>
+            <button class="preset-btn" onclick="setAllLoads(10)">10%</button>
+            <button class="preset-btn" onclick="setAllLoads(25)">25%</button>
+            <button class="preset-btn" onclick="setAllLoads(50)">50%</button>
+            <button class="preset-btn" onclick="setAllLoads(80)">80%</button>
+            <button class="preset-btn" onclick="setAllLoads(90)">90%</button>
+            <button class="preset-btn" onclick="setAllLoads(100)">100%</button>
+        </div>
+
+        <div id="thread-controls" class="thread-controls">
+            <!-- Thread controls will be dynamically inserted here -->
+        </div>
+    </div>
+
+    <script>
+        let numThreads = 0;
+        let updateTimeout = null;
+        let ws = null;
+        let numCPUs = 0;
+
+        function connectWebSocket() {
+            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+            const wsUrl = `${protocol}//${window.location.host}/ws/cpu-metrics`;
+
+            ws = new WebSocket(wsUrl);
+
+            ws.onopen = () => {
+                console.log('WebSocket connected');
+            };
+
+            ws.onmessage = (event) => {
+                const data = JSON.parse(event.data);
+                if (data.type === 'cpu_metrics') {
+                    updateCPUMetrics(data);
+                }
+            };
+
+            ws.onerror = (error) => {
+                console.error('WebSocket error:', error);
+            };
+
+            ws.onclose = () => {
+                console.log('WebSocket disconnected, reconnecting...');
+                setTimeout(connectWebSocket, 2000);
+            };
+        }
+
+        function updateCPUMetrics(data) {
+            // Update total CPU
+            const totalCpu = data.total_cpu_percent;
+            document.getElementById('total-cpu-value').textContent = `${totalCpu}%`;
+            document.getElementById('total-cpu-bar').style.width = `${totalCpu}%`;
+
+            // Update per-CPU bars
+            const perCpuContainer = document.getElementById('per-cpu-bars');
+            if (data.per_cpu_percent.length !== numCPUs) {
+                numCPUs = data.per_cpu_percent.length;
+                // Recreate all CPU bars
+                perCpuContainer.innerHTML = '';
+                data.per_cpu_percent.forEach((cpu, index) => {
+                    const barHtml = `
+                        <div class="cpu-bar-container">
+                            <div class="cpu-bar-label">
+                                <span>CPU ${index}</span>
+                                <span id="cpu-${index}-value">-</span>
+                            </div>
+                            <div class="cpu-bar-wrapper">
+                                <div class="cpu-bar" id="cpu-${index}-bar" style="width: 0%"></div>
+                            </div>
+                        </div>
+                    `;
+                    perCpuContainer.insertAdjacentHTML('beforeend', barHtml);
+                });
+            }
+
+            // Update values
+            data.per_cpu_percent.forEach((cpu, index) => {
+                document.getElementById(`cpu-${index}-value`).textContent = `${cpu}%`;
+                document.getElementById(`cpu-${index}-bar`).style.width = `${cpu}%`;
+            });
+        }
+
+        async function fetchStatus() {
+            try {
+                const response = await fetch('/api/threads');
+                const data = await response.json();
+
+                numThreads = data.num_threads;
+                document.getElementById('thread-count').textContent = numThreads;
+
+                // Calculate average load
+                const loads = Object.values(data.loads);
+                const avgLoad = loads.length > 0
+                    ? (loads.reduce((a, b) => a + b, 0) / loads.length).toFixed(1)
+                    : 0;
+                document.getElementById('avg-load').textContent = avgLoad;
+
+                // Update or create thread controls
+                updateThreadControls(data.loads);
+            } catch (error) {
+                showError('Failed to fetch status: ' + error.message);
+            }
+        }
+
+        function updateThreadControls(loads) {
+            const container = document.getElementById('thread-controls');
+
+            // If number of threads changed, recreate all controls
+            if (container.children.length !== Object.keys(loads).length) {
+                container.innerHTML = '';
+
+                for (let i = 0; i < Object.keys(loads).length; i++) {
+                    const control = createThreadControl(i, loads[i]);
+                    container.appendChild(control);
+                }
+            } else {
+                // Just update values
+                Object.entries(loads).forEach(([threadId, load]) => {
+                    const slider = document.getElementById(`slider-${threadId}`);
+                    const value = document.getElementById(`value-${threadId}`);
+                    if (slider && value) {
+                        slider.value = load;
+                        value.textContent = load.toFixed(0) + '%';
+                    }
+                });
+            }
+        }
+
+        function createThreadControl(threadId, initialLoad) {
+            const div = document.createElement('div');
+            div.className = 'thread-control';
+            div.innerHTML = `
+                <div class="thread-header">
+                    <span class="thread-label">Thread ${threadId}</span>
+                    <span class="thread-value" id="value-${threadId}">
+                        ${initialLoad.toFixed(0)}%
+                    </span>
+                </div>
+                <div class="slider-container">
+                    <input type="range" min="0" max="100" value="${initialLoad}"
+                           class="slider" id="slider-${threadId}"
+                           oninput="updateThreadLoad(${threadId}, this.value)">
+                    <div class="slider-labels">
+                        <span>0%</span>
+                        <span>25%</span>
+                        <span>50%</span>
+                        <span>75%</span>
+                        <span>100%</span>
+                    </div>
+                </div>
+            `;
+            return div;
+        }
+
+        async function updateThreadLoad(threadId, loadPercent) {
+            // Update UI immediately for responsiveness
+            document.getElementById(`value-${threadId}`).textContent = loadPercent + '%';
+
+            // Debounce API calls
+            if (updateTimeout) {
+                clearTimeout(updateTimeout);
+            }
+
+            updateTimeout = setTimeout(async () => {
+                try {
+                    const response = await fetch(`/api/threads/${threadId}/load`, {
+                        method: 'PUT',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({ load_percent: parseFloat(loadPercent) })
+                    });
+
+                    if (!response.ok) {
+                        throw new Error('Failed to update thread load');
+                    }
+
+                    // Refresh status to get accurate average
+                    await fetchStatus();
+                } catch (error) {
+                    showError('Failed to update thread ' + threadId + ': ' + error.message);
+                }
+            }, 100);
+        }
+
+        async function setAllLoads(loadPercent) {
+            try {
+                const response = await fetch('/api/threads/load/all', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ load_percent: loadPercent })
+                });
+
+                if (!response.ok) {
+                    throw new Error('Failed to set loads');
+                }
+
+                showSuccess(`All threads set to ${loadPercent}%`);
+
+                // Update UI
+                await fetchStatus();
+            } catch (error) {
+                showError('Failed to set all loads: ' + error.message);
+            }
+        }
+
+        function showError(message) {
+            const errorDiv = document.getElementById('error-message');
+            errorDiv.textContent = message;
+            errorDiv.style.display = 'block';
+            setTimeout(() => {
+                errorDiv.style.display = 'none';
+            }, 5000);
+        }
+
+        function showSuccess(message) {
+            const successDiv = document.getElementById('success-message');
+            successDiv.textContent = message;
+            successDiv.style.display = 'block';
+            setTimeout(() => {
+                successDiv.style.display = 'none';
+            }, 3000);
+        }
+
+        // Initial load and periodic refresh
+        fetchStatus();
+        connectWebSocket();
+        setInterval(fetchStatus, 5000);
+    </script>
+</body>
+</html>

{cpu_loader-0.1.3 → cpu_loader-0.2.4/src/cpu_loader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpu-loader
-Version: 0.1.3
+Version: 0.2.4
 Summary: A tool to generate CPU load on a system with runtime configuration through a WebUI and REST API
 Author-email: the78mole <the78mole@users.noreply.github.com>
 License: MIT

{cpu_loader-0.1.3 → cpu_loader-0.2.4}/src/cpu_loader.egg-info/SOURCES.txt

@@ -15,4 +15,5 @@ src/cpu_loader.egg-info/SOURCES.txt
 src/cpu_loader.egg-info/dependency_links.txt
 src/cpu_loader.egg-info/entry_points.txt
 src/cpu_loader.egg-info/requires.txt
-src/cpu_loader.egg-info/top_level.txt
+src/cpu_loader.egg-info/top_level.txt
+src/cpu_loader/templates/index.html