Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-7-sonnet-20250219· AnthropicHugging Face LMArena Human Preference 140K

напиши утилиту на пайтон в одном файле вначале идет установщий в систему то есть…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Coherecommand-a-03-2025’s answer.
  1. User

    напиши утилиту на пайтон в одном файле вначале идет установщий в систему то есть установка нужных этих ну да крч после идет выбор что нужно это хостить мейн штуку с фронтендом и мониторингом и терминалом всех серверов и т.д а второй выбор этой установить всю штуку ты пишешь айпи куда отправлять и вообще ну куда подключаться берешь ключ (38 символов) и вставляешь из мейн сервера и потом уже все показывается на фронтенде

  2. Claude Assistant

    Вот утилита на Python, которая соответствует вашим требованиям:

    #!/usr/bin/env python3
    import os
    import sys
    import subprocess
    import socket
    import time
    import threading
    import json
    import uuid
    import argparse
    import getpass
    from pathlib import Path
    import platform
    import re
    import random
    import string
    
    # Цвета для терминала
    class Colors:
        HEADER = '\033[95m'
        BLUE = '\033[94m'
        GREEN = '\033[92m'
        WARNING = '\033[93m'
        FAIL = '\033[91m'
        ENDC = '\033[0m'
        BOLD = '\033[1m'
    
    # Проверка зависимостей и установка необходимых пакетов
    def check_and_install_dependencies():
        print(f"{Colors.HEADER}Проверка и установка зависимостей...{Colors.ENDC}")
        
        required_packages = [
            "flask", "flask-socketio", "psutil", "paramiko", 
            "requests", "cryptography", "netifaces", "docker"
        ]
        
        try:
            import pkg_resources
            installed = {pkg.key for pkg in pkg_resources.working_set}
            missing = [pkg for pkg in required_packages if pkg not in installed]
            
            if missing:
                print(f"{Colors.WARNING}Установка недостающих пакетов: {', '.join(missing)}{Colors.ENDC}")
                subprocess.check_call([sys.executable, "-m", "pip", "install", *missing])
                print(f"{Colors.GREEN}Все зависимости установлены успешно!{Colors.ENDC}")
            else:
                print(f"{Colors.GREEN}Все необходимые пакеты уже установлены.{Colors.ENDC}")
        except Exception as e:
            print(f"{Colors.FAIL}Ошибка при установке зависимостей: {str(e)}{Colors.ENDC}")
            sys.exit(1)
    
    # Генерация ключа для подключения серверов
    def generate_key():
        return ''.join(random.choices(string.ascii_letters + string.digits, k=38))
    
    # Класс для управления серверами
    class ServerManager:
        def __init__(self, is_main=False):
            self.is_main = is_main
            self.servers = {}
            self.key = generate_key() if is_main else None
            self.config_dir = Path.home() / ".server_monitor"
            self.config_file = self.config_dir / "config.json"
            self.load_config()
        
        def load_config(self):
            if not self.config_dir.exists():
                self.config_dir.mkdir(parents=True)
            
            if self.config_file.exists():
                try:
                    with open(self.config_file, 'r') as f:
                        config = json.load(f)
                        if self.is_main:
                            self.key = config.get('key', generate_key())
                        self.servers = config.get('servers', {})
                except Exception as e:
                    print(f"{Colors.FAIL}Ошибка при загрузке конфигурации: {str(e)}{Colors.ENDC}")
                    if self.is_main:
                        self.key = generate_key()
            else:
                self.save_config()
        
        def save_config(self):
            try:
                config = {
                    'key': self.key,
                    'servers': self.servers
                }
                with open(self.config_file, 'w') as f:
                    json.dump(config, f, indent=2)
            except Exception as e:
                print(f"{Colors.FAIL}Ошибка при сохранении конфигурации: {str(e)}{Colors.ENDC}")
        
        def add_server(self, ip, name=None):
            if not name:
                name = f"Server-{len(self.servers) + 1}"
            
            server_id = str(uuid.uuid4())
            self.servers[server_id] = {
                'ip': ip,
                'name': name,
                'status': 'pending',
                'last_seen': time.time()
            }
            self.save_config()
            return server_id
        
        def remove_server(self, server_id):
            if server_id in self.servers:
                del self.servers[server_id]
                self.save_config()
                return True
            return False
        
        def get_server_status(self, server_id):
            if server_id in self.servers:
                return self.servers[server_id]
            return None
        
        def update_server_status(self, server_id, status_data):
            if server_id in self.servers:
                self.servers[server_id].update(status_data)
                self.servers[server_id]['last_seen'] = time.time()
                self.save_config()
                return True
            return False
    
    # Класс для мониторинга системы
    class SystemMonitor:
        def __init__(self):
            import psutil
            self.psutil = psutil
        
        def get_system_info(self):
            try:
                cpu_percent = self.psutil.cpu_percent(interval=1)
                memory = self.psutil.virtual_memory()
                disk = self.psutil.disk_usage('/')
                
                # Получение информации о сети
                net_io = self.psutil.net_io_counters()
                
                return {
                    'hostname': socket.gethostname(),
                    'platform': platform.platform(),
                    'cpu': {
                        'percent': cpu_percent,
                        'cores': self.psutil.cpu_count()
                    },
                    'memory': {
                        'total': memory.total,
                        'available': memory.available,
                        'percent': memory.percent
                    },
                    'disk': {
                        'total': disk.total,
                        'used': disk.used,
                        'free': disk.free,
                        'percent': disk.percent
                    },
                    'network': {
                        'bytes_sent': net_io.bytes_sent,
                        'bytes_recv': net_io.bytes_recv
                    },
                    'timestamp': time.time()
                }
            except Exception as e:
                return {'error': str(e)}
    
    # Класс для веб-сервера (фронтенд)
    class WebServer:
        def __init__(self, server_manager, port=5000):
            self.server_manager = server_manager
            self.port = port
            
        def start(self):
            from flask import Flask, render_template, request, jsonify
            from flask_socketio import SocketIO
            
            app = Flask(__name__, template_folder=str(self.create_templates()))
            socketio = SocketIO(app)
            
            @app.route('/')
            def index():
                return render_template('index.html', key=self.server_manager.key)
            
            @app.route('/api/servers', methods=['GET'])
            def get_servers():
                return jsonify(self.server_manager.servers)
            
            @app.route('/api/servers', methods=['POST'])
            def add_server():
                data = request.json
                if 'ip' not in data:
                    return jsonify({'error': 'IP address is required'}), 400
                
                server_id = self.server_manager.add_server(data['ip'], data.get('name'))
                return jsonify({'id': server_id})
            
            @app.route('/api/servers/<server_id>', methods=['DELETE'])
            def remove_server(server_id):
                success = self.server_manager.remove_server(server_id)
                if success:
                    return jsonify({'success': True})
                return jsonify({'error': 'Server not found'}), 404
            
            @app.route('/api/update', methods=['POST'])
            def update_server():
                data = request.json
                if 'key' not in data or data['key'] != self.server_manager.key:
                    return jsonify({'error': 'Invalid key'}), 403
                
                if 'id' not in data:
                    # Новый сервер, создаем ID
                    server_id = self.server_manager.add_server(request.remote_addr)
                    data['id'] = server_id
                
                success = self.server_manager.update_server_status(data['id'], data['status'])
                if success:
                    # Отправляем обновление через WebSocket
                    socketio.emit('server_update', data)
                    return jsonify({'success': True})
                
                return jsonify({'error': 'Server not found'}), 404
            
            print(f"{Colors.GREEN}Запуск веб-сервера на порту {self.port}...{Colors.ENDC}")
            print(f"{Colors.BOLD}Ваш ключ для подключения: {self.server_manager.key}{Colors.ENDC}")
            print(f"{Colors.BLUE}Откройте http://localhost:{self.port} в браузере для доступа к панели мониторинга{Colors.ENDC}")
            
            socketio.run(app, host='0.0.0.0', port=self.port)
        
        def create_templates(self):
            templates_dir = Path.home() / ".server_monitor" / "templates"
            if not templates_dir.exists():
                templates_dir.mkdir(parents=True)
            
            # Создаем базовый HTML шаблон
            index_html = templates_dir / "index.html"
            if not index_html.exists():
                with open(index_html, 'w') as f:
                    f.write("""<!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Мониторинг серверов</title>
        <style>
            body {
                font-family: Arial, sans-serif;
                margin: 0;
                padding: 20px;
                background-color: #f5f5f5;
            }
            .container {
                max-width: 1200px;
                margin: 0 auto;
            }
            .header {
                display: flex;
                justify-content: space-between;
                align-items: center;
                margin-bottom: 20px;
            }
            .key-info {
                background-color: #e9f7ef;
                padding: 10px;
                border-radius: 5px;
                margin-bottom: 20px;
            }
            .servers-grid {
                display: grid;
                grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
                gap: 20px;
            }
            .server-card {
                background-color: white;
                border-radius: 8px;
                box-shadow: 0 2px 5px rgba(0,0,0,0.1);
                padding: 15px;
            }
            .server-header {
                display: flex;
                justify-content: space-between;
                margin-bottom: 10px;
            }
            .server-name {
                font-weight: bold;
                font-size: 18px;
            }
            .status-online {
                color: green;
            }
            .status-offline {
                color: red;
            }
            .progress-bar {
                height: 10px;
                background-color: #e0e0e0;
                border-radius: 5px;
                margin: 5px 0;
            }
            .progress-fill {
                height: 100%;
                border-radius: 5px;
                background-color: #4caf50;
            }
            .add-server-form {
                background-color: white;
                padding: 20px;
                border-radius: 8px;
                box-shadow: 0 2px 5px rgba(0,0,0,0.1);
                margin-bottom: 20px;
            }
            input, button {
                padding: 8px 12px;
                margin: 5px;
                border-radius: 4px;
                border: 1px solid #ddd;
            }
            button {
                background-color: #4caf50;
                color: white;
                border: none;
                cursor: pointer;
            }
            button:hover {
                background-color: #45a049;
            }
            .terminal {
                background-color: #1e1e1e;
                color: #f0f0f0;
                padding: 10px;
                border-radius: 5px;
                font-family: monospace;
                margin-top: 10px;
                max-height: 200px;
                overflow-y: auto;
            }
        </style>
    </head>
    <body>
        <div class="container">
            <div class="header">
                <h1>Мониторинг серверов</h1>
                <button id="refresh-btn">Обновить</button>
            </div>
            
            <div class="key-info">
                <h3>Ключ подключения:</h3>
                <code id="connection-key">{{ key }}</code>
                <p>Используйте этот ключ для подключения новых серверов к системе мониторинга.</p>
            </div>
            
            <div class="add-server-form">
                <h3>Добавить сервер вручную</h3>
                <input type="text" id="server-ip" placeholder="IP адрес">
                <input type="text" id="server-name" placeholder="Название (опционально)">
                <button id="add-server-btn">Добавить</button>
            </div>
            
            <h2>Серверы</h2>
            <div class="servers-grid" id="servers-container">
                <!-- Здесь будут карточки серверов -->
            </div>
        </div>
    
        <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"></script>
        <script>
            // Подключение к WebSocket
            const socket = io();
            
            // Обработка обновлений от сервера
            socket.on('server_update', function(data) {
                updateServerCard(data.id, data.status);
            });
            
            // Загрузка списка серверов при загрузке страницы
            document.addEventListener('DOMContentLoaded', function() {
                loadServers();
                
                // Обработчик кнопки обновления
                document.getElementById('refresh-btn').addEventListener('click', loadServers);
                
                // Обработчик добавления сервера
                document.getElementById('add-server-btn').addEventListener('click', addServer);
            });
            
            // Функция загрузки списка серверов
            function loadServers() {
                fetch('/api/servers')
                    .then(response => response.json())
                    .then(servers => {
                        const container = document.getElementById('servers-container');
                        container.innerHTML = '';
                        
                        if (Object.keys(servers).length === 0) {
                            container.innerHTML = '<p>Нет подключенных серверов</p>';
                            return;
                        }
                        
                        for (const [id, server] of Object.entries(servers)) {
                            container.appendChild(createServerCard(id, server));
                        }
                    })
                    .catch(error => console.error('Ошибка при загрузке серверов:', error));
            }
            
            // Создание карточки сервера
            function createServerCard(id, server) {
                const card =
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.