Update app.py

app.py

@@ -116,6 +116,825 @@ def run_fastapi():
     """تشغيل FastAPI في thread منفصل"""
     threading.Thread(target=health_check_loop, daemon=True).start()
     uvicorn.run(app, host="0.0.0.0", port=PORT)
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+نظام توزيع المهام الذكي - الخادم المركزي على Hugging Face
+يجمع بين واجهة Gradio وخادم التوزيع المركزي
+"""
+
+import os
+import sys
+import time
+import json
+import logging
+import threading
+import random
+import queue
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, field, asdict
+
+import gradio as gr
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import requests
+
+# ─────────────── إعداد السجلات ───────────────
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("CentralServerHF")
+
+# ─────────────── هياكل البيانات ───────────────
+@dataclass
+class NodeInfo:
+    """معلومات العقدة المتصلة"""
+    node_id: str
+    ip: str
+    port: int
+    url: str
+    capabilities: List[str]
+    cpu_usage: float = 0.0
+    memory_usage: float = 0.0
+    status: str = "online"
+    last_seen: datetime = field(default_factory=datetime.now)
+    success_rate: float = 1.0
+    response_time: float = 0.0
+    tasks_completed: int = 0
+    tasks_failed: int = 0
+    current_tasks: int = 0
+    weight: float = 1.0  # للأوزان الذكية
+    
+    @property
+    def score(self) -> float:
+        """حساب درجة العقدة"""
+        health = 0.4 * (100 - (self.cpu_usage + self.memory_usage) / 2) / 100
+        performance = 0.3 * self.success_rate
+        availability = 0.2 * (1.0 - self.current_tasks / 5)
+        speed = 0.1 * max(0, 1 - self.response_time / 10)
+        
+        return (health + performance + availability + speed) * self.weight
+
+@dataclass
+class TaskInfo:
+    """معلومات المهمة"""
+    task_id: str
+    task_type: str
+    params: Dict[str, Any]
+    sender: str
+    status: str = "pending"  # pending, processing, completed, failed
+    assigned_to: Optional[str] = None
+    result: Optional[Any] = None
+    error: Optional[str] = None
+    created_at: datetime = field(default_factory=datetime.now)
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    priority: int = 2  # 1=high, 2=medium, 3=low
+
+# ─────────────── فئة الخادم المركزي ───────────────
+class CentralServer:
+    """الخادم المركزي الذكي لتوزيع المهام"""
+    
+    def __init__(self):
+        self.nodes: Dict[str, NodeInfo] = {}
+        self.tasks: Dict[str, TaskInfo] = {}
+        self.task_queue = queue.PriorityQueue()
+        self.lock = threading.RLock()
+        self.is_running = True
+        
+        # إحصائيات النظام
+        self.metrics = {
+            "total_nodes": 0,
+            "online_nodes": 0,
+            "total_tasks": 0,
+            "completed_tasks": 0,
+            "failed_tasks": 0,
+            "avg_response_time": 0.0,
+            "system_uptime": time.time()
+        }
+        
+        # بدء الخدمات الخلفية
+        self._start_background_services()
+        
+        logger.info("🚀 بدء تشغيل الخادم المركزي على Hugging Face")
+    
+    def _start_background_services(self):
+        """بدء الخدمات الخلفية"""
+        # خيط توزيع المهام
+        self.dispatcher = threading.Thread(target=self._dispatch_loop, daemon=True)
+        self.dispatcher.start()
+        
+        # خيط فحص صحة العقد
+        self.health_checker = threading.Thread(target=self._health_check_loop, daemon=True)
+        self.health_checker.start()
+        
+        # خيط محاكاة العقد (للتجربة)
+        self.simulator = threading.Thread(target=self._simulate_nodes, daemon=True)
+        self.simulator.start()
+    
+    def register_node(self, node_data: Dict) -> Dict:
+        """تسجيل عقدة جديدة"""
+        with self.lock:
+            node_id = node_data.get('node_id', f"node_{len(self.nodes)+1}")
+            
+            node = NodeInfo(
+                node_id=node_id,
+                ip=node_data.get('ip', '127.0.0.1'),
+                port=node_data.get('port', 0),
+                url=node_data.get('url', ''),
+                capabilities=node_data.get('capabilities', ['general']),
+                cpu_usage=node_data.get('cpu_usage', 0.0),
+                memory_usage=node_data.get('memory_usage', 0.0),
+                status='online'
+            )
+            
+            self.nodes[node_id] = node
+            self.metrics["total_nodes"] = len(self.nodes)
+            self.metrics["online_nodes"] = len([n for n in self.nodes.values() if n.status == 'online'])
+            
+            logger.info(f"✅ عقدة مسجلة: {node_id}")
+            
+            return {
+                "status": "success",
+                "node_id": node_id,
+                "message": "تم التسجيل بنجاح",
+                "server_time": datetime.now().isoformat()
+            }
+    
+    def update_node_status(self, node_id: str, metrics: Dict):
+        """تحديث حالة العقدة"""
+        with self.lock:
+            if node_id in self.nodes:
+                node = self.nodes[node_id]
+                
+                if 'cpu_usage' in metrics:
+                    node.cpu_usage = metrics['cpu_usage']
+                if 'memory_usage' in metrics:
+                    node.memory_usage = metrics['memory_usage']
+                if 'current_tasks' in metrics:
+                    node.current_tasks = metrics['current_tasks']
+                if 'status' in metrics:
+                    node.status = metrics['status']
+                
+                node.last_seen = datetime.now()
+                
+                # تحديث معدل النجاح
+                total = node.tasks_completed + node.tasks_failed
+                if total > 0:
+                    node.success_rate = node.tasks_completed / total
+                
+                return {"status": "updated"}
+            
+            return {"error": "العقدة غير موجودة"}
+    
+    def submit_task(self, task_data: Dict) -> Dict:
+        """إرسال مهمة جديدة"""
+        task_id = task_data.get('task_id', f"task_{int(time.time())}_{random.randint(1000,9999)}")
+        
+        task = TaskInfo(
+            task_id=task_id,
+            task_type=task_data.get('task_type', 'general'),
+            params=task_data.get('params', {}),
+            sender=task_data.get('sender', 'unknown'),
+            priority=task_data.get('priority', 2)
+        )
+        
+        with self.lock:
+            self.tasks[task_id] = task
+            self.metrics["total_tasks"] = len(self.tasks)
+        
+        # إضافة إلى قائمة الانتظار
+        self.task_queue.put((task.priority, task_id))
+        
+        logger.info(f"📨 مهمة مستلمة: {task_id} ({task.task_type})")
+        
+        return {
+            "status": "accepted",
+            "task_id": task_id,
+            "queue_position": self.task_queue.qsize(),
+            "estimated_wait": self.task_queue.qsize() * 2  # ثانيتين لكل مهمة
+        }
+    
+    def _dispatch_loop(self):
+        """حلقة توزيع المهام"""
+        while self.is_running:
+            try:
+                # انتظار مهمة
+                priority, task_id = self.task_queue.get(timeout=1.0)
+                
+                with self.lock:
+                    task = self.tasks.get(task_id)
+                    if not task or task.status != "pending":
+                        continue
+                
+                # إيجاد أفضل عقدة
+                best_node = self._select_best_node(task.task_type)
+                
+                if best_node:
+                    # تعيين المهمة
+                    self._assign_task(task, best_node)
+                else:
+                    # إعادة المحاولة
+                    time.sleep(3)
+                    self.task_queue.put((priority, task_id))
+                    
+            except queue.Empty:
+                continue
+            except Exception as e:
+                logger.error(f"❌ خطأ في التوزيع: {e}")
+                time.sleep(5)
+    
+    def _select_best_node(self, task_type: str) -> Optional[NodeInfo]:
+        """اختيار أفضل عقدة للمهمة"""
+        with self.lock:
+            # فلترة العقد المتاحة
+            available = []
+            for node in self.nodes.values():
+                if node.status != 'online':
+                    continue
+                if node.cpu_usage > 85 or node.memory_usage > 85:
+                    continue
+                if node.current_tasks >= 3:
+                    continue
+                
+                # التحقق من القدرات
+                capabilities_needed = []
+                if task_type in ['matrix', 'fibonacci']:
+                    capabilities_needed = ['cpu_intensive']
+                elif task_type in ['data', 'processing']:
+                    capabilities_needed = ['memory']
+                
+                if capabilities_needed:
+                    if not any(cap in node.capabilities for cap in capabilities_needed):
+                        continue
+                
+                available.append(node)
+            
+            if not available:
+                return None
+            
+            # اختيار الأعلى درجة
+            return max(available, key=lambda n: n.score)
+    
+    def _assign_task(self, task: TaskInfo, node: NodeInfo):
+        """تعيين مهمة لعقدة"""
+        try:
+            # تحديث حالة المهمة
+            with self.lock:
+                task.status = "processing"
+                task.assigned_to = node.node_id
+                task.started_at = datetime.now()
+                node.current_tasks += 1
+            
+            logger.info(f"🎯 تعيين {task.task_id} → {node.node_id}")
+            
+            # محاكاة التنفيذ
+            execution_time = self._simulate_task_execution(task, node)
+            
+            # تحديث النتيجة
+            with self.lock:
+                task.status = "completed"
+                task.completed_at = datetime.now()
+                task.result = {
+                    "executed_on": node.node_id,
+                    "execution_time": execution_time,
+                    "task_type": task.task_type,
+                    "result": f"نتيجة محاكاة لـ {task.task_type}"
+                }
+                
+                node.current_tasks -= 1
+                node.tasks_completed += 1
+                node.response_time = execution_time
+                
+                self.metrics["completed_tasks"] += 1
+            
+            logger.info(f"✅ مكتملة: {task.task_id} في {execution_time:.2f}s")
+            
+        except Exception as e:
+            logger.error(f"❌ فشلت المهمة {task.task_id}: {e}")
+            
+            with self.lock:
+                task.status = "failed"
+                task.error = str(e)
+                self.metrics["failed_tasks"] += 1
+                
+                if node.node_id in self.nodes:
+                    self.nodes[node.node_id].tasks_failed += 1
+                    self.nodes[node.node_id].current_tasks -= 1
+    
+    def _simulate_task_execution(self, task: TaskInfo, node: NodeInfo) -> float:
+        """محاكاة تنفيذ المهمة"""
+        # أوقات تنفيذ مختلفة حسب نوع المهمة
+        base_times = {
+            'matrix': 1.5,
+            'fibonacci': 0.8,
+            'primes': 1.2,
+            'data': 0.5,
+            'image': 2.0,
+            'general': 0.3
+        }
+        
+        base_time = base_times.get(task.task_type, 0.5)
+        
+        # تأثير حمل العقدة
+        load_factor = 1 + (node.cpu_usage + node.memory_usage) / 200
+        
+        # تأثير حجم المهمة
+        size = task.params.get('size', 10) if isinstance(task.params, dict) else 10
+        size_factor = 1 + (size / 1000)
+        
+        # وقت تنفيذ محاكي
+        execution_time = base_time * load_factor * size_factor
+        
+        # محاكاة الانتظار
+        time.sleep(min(execution_time, 3.0))
+        
+        return execution_time
+    
+    def _health_check_loop(self):
+        """فحص صحة العقد"""
+        while self.is_running:
+            try:
+                with self.lock:
+                    now = datetime.now()
+                    for node in self.nodes.values():
+                        # إذا مر أكثر من 2 دقيقة دون تحديث
+                        if (now - node.last_seen).total_seconds() > 120:
+                            node.status = "offline"
+                    
+                    # تحديث الإحصائيات
+                    self.metrics["online_nodes"] = len(
+                        [n for n in self.nodes.values() if n.status == 'online']
+                    )
+                
+                time.sleep(30)
+                
+            except Exception as e:
+                logger.error(f"❌ خطأ في فحص الصحة: {e}")
+                time.sleep(60)
+    
+    def _simulate_nodes(self):
+        """محاكاة عقد افتراضية (للتجربة)"""
+        # إنشاء عقد افتراضية
+        virtual_nodes = [
+            {"id": "node_cpu1", "capabilities": ["cpu_intensive"], "cpu": 20, "memory": 40},
+            {"id": "node_mem1", "capabilities": ["memory"], "cpu": 30, "memory": 25},
+            {"id": "node_gpu1", "capabilities": ["gpu", "image"], "cpu": 25, "memory": 50},
+            {"id": "node_gen1", "capabilities": ["general"], "cpu": 15, "memory": 35}
+        ]
+        
+        for vnode in virtual_nodes:
+            self.register_node({
+                "node_id": vnode["id"],
+                "ip": "192.168.1." + str(random.randint(100, 200)),
+                "port": random.randint(5000, 6000),
+                "url": f"http://192.168.1.{random.randint(100,200)}:{random.randint(5000,6000)}",
+                "capabilities": vnode["capabilities"],
+                "cpu_usage": vnode["cpu"],
+                "memory_usage": vnode["memory"]
+            })
+        
+        # محاكاة تحديثات دورية
+        while self.is_running:
+            try:
+                with self.lock:
+                    for node_id in list(self.nodes.keys())[:4]:  # أول 4 عقد (الافتراضية)
+                        if node_id in self.nodes:
+                            node = self.nodes[node_id]
+                            node.cpu_usage = max(5, min(80, node.cpu_usage + random.uniform(-5, 5)))
+                            node.memory_usage = max(10, min(70, node.memory_usage + random.uniform(-3, 3)))
+                            node.current_tasks = random.randint(0, 2)
+                            node.last_seen = datetime.now()
+                
+                time.sleep(10)
+                
+            except Exception as e:
+                logger.error(f"❌ خطأ في محاكاة العقد: {e}")
+                time.sleep(30)
+    
+    def get_system_overview(self) -> Dict:
+        """نظرة عامة على النظام"""
+        with self.lock:
+            now = datetime.now()
+            
+            # حساب متوسط وقت الاستجابة
+            response_times = [n.response_time for n in self.nodes.values() if n.response_time > 0]
+            avg_response = sum(response_times) / len(response_times) if response_times else 0
+            
+            # المهام الأخيرة
+            recent_tasks = list(self.tasks.values())[-10:]  # آخر 10 مهام
+            
+            return {
+                "metrics": {
+                    **self.metrics,
+                    "uptime": time.time() - self.metrics["system_uptime"],
+                    "avg_response_time": avg_response,
+                    "queue_size": self.task_queue.qsize(),
+                    "timestamp": now.isoformat()
+                },
+                "nodes": [
+                    {
+                        "id": n.node_id,
+                        "status": n.status,
+                        "score": round(n.score, 3),
+                        "cpu": n.cpu_usage,
+                        "memory": n.memory_usage,
+                        "tasks": n.current_tasks,
+                        "success_rate": round(n.success_rate, 2),
+                        "last_seen": (now - n.last_seen).total_seconds()
+                    }
+                    for n in self.nodes.values()
+                ],
+                "recent_tasks": [
+                    {
+                        "id": t.task_id,
+                        "type": t.task_type,
+                        "status": t.status,
+                        "assigned_to": t.assigned_to,
+                        "created": t.created_at.strftime("%H:%M:%S")
+                    }
+                    for t in recent_tasks
+                ]
+            }
+
+# ─────────────── إنشاء الخادم المركزي ───────────────
+central_server = CentralServer()
+
+# ─────────────── دوال Gradio ───────────────
+def get_system_status():
+    """الحصول على حالة النظام"""
+    overview = central_server.get_system_overview()
+    
+    metrics = overview["metrics"]
+    nodes = overview["nodes"]
+    tasks = overview["recent_tasks"]
+    
+    # تنسيق النص
+    status_text = f"""
+# 🌐 الخادم المركزي لتوزيع المهام
+
+## 📊 إحصائيات النظام
+- **الوقت:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+- **مدة التشغيل:** {metrics['uptime']/3600:.1f} ساعة
+- **العقد الإجمالية:** {metrics['total_nodes']}
+- **العقد النشطة:** {metrics['online_nodes']}
+- **المهام الإجمالية:** {metrics['total_tasks']}
+- **المهام المكتملة:** {metrics['completed_tasks']}
+- **المهام الفاشلة:** {metrics['failed_tasks']}
+- **متوسط وقت الاستجابة:** {metrics['avg_response_time']:.2f} ثانية
+- **المهام في الانتظار:** {metrics['queue_size']}
+
+## 👥 العقد المتصلة ({len(nodes)})
+"""
+    
+    for node in nodes:
+        status_emoji = "🟢" if node['status'] == 'online' else "🔴" if node['status'] == 'offline' else "🟡"
+        status_text += f"\n**{status_emoji} {node['id']}**"
+        status_text += f"\n  - النقاط: {node['score']:.3f}"
+        status_text += f"\n  - CPU: {node['cpu']:.1f}% | ذاكرة: {node['memory']:.1f}%"
+        status_text += f"\n  - المهام النشطة: {node['tasks']}"
+        status_text += f"\n  - معدل النجاح: {node['success_rate']*100:.1f}%"
+        status_text += f"\n  - آخر ظهور: {node['last_seen']:.0f} ثانية مضت"
+    
+    if tasks:
+        status_text += f"\n\n## 📋 آخر المهام ({len(tasks)})"
+        for task in tasks[-5:]:  # آخر 5 مهام
+            status_emoji = "🟢" if task['status'] == 'completed' else "🟡" if task['status'] == 'processing' else "🔴"
+            status_text += f"\n{status_emoji} **{task['id']}** ({task['type']}) → {task['assigned_to'] or 'في الانتظار'}"
+    
+    return status_text
+
+def submit_task_ui(task_type, params_json):
+    """إرسال مهمة جديدة"""
+    try:
+        params = json.loads(params_json) if params_json else {}
+    except:
+        params = {"size": 10}
+    
+    task_data = {
+        "task_type": task_type,
+        "params": params,
+        "sender": "gradio_ui",
+        "priority": 2
+    }
+    
+    result = central_server.submit_task(task_data)
+    
+    if "error" in result:
+        return f"## ❌ خطأ\n{result['error']}"
+    
+    return f"""
+## ✅ تم قبول المهمة
+
+### 📝 معلومات المهمة
+- **معرف المهمة:** {result['task_id']}
+- **نوع المهمة:** {task_type}
+- **الحالة:** في قائمة الانتظار
+- **الموقع في الطابور:** {result['queue_position']}
+- **الوقت المتوقع:** {result['estimated_wait']} ثانية
+- **الوقت:** {datetime.now().strftime('%H:%M:%S')}
+
+### 📊 تتبع المهمة
+سيتم تعيين المهمة لأفضل عقدة متاحة تلقائياً.
+"""
+
+def get_node_details():
+    """الحصول على تفاصيل العقد"""
+    overview = central_server.get_system_overview()
+    nodes = overview["nodes"]
+    
+    headers = ["العقدة", "الحالة", "النقاط", "CPU%", "الذاكرة%", "المهام", "معدل النجاح", "آخر ظهور"]
+    data = []
+    
+    for node in nodes:
+        status_emoji = "🟢" if node['status'] == 'online' else "🔴"
+        data.append([
+            node['id'],
+            f"{status_emoji} {node['status']}",
+            f"{node['score']:.3f}",
+            f"{node['cpu']:.1f}",
+            f"{node['memory']:.1f}",
+            str(node['tasks']),
+            f"{node['success_rate']*100:.1f}%",
+            f"{node['last_seen']:.0f}s"
+        ])
+    
+    return data
+
+def simulate_new_node():
+    """محاكاة عقدة جديدة"""
+    node_id = f"node_{int(time.time())}"
+    caps = random.choice([['cpu_intensive'], ['memory'], ['general'], ['gpu', 'image']])
+    
+    result = central_server.register_node({
+        "node_id": node_id,
+        "ip": f"10.0.0.{random.randint(1, 255)}",
+        "port": random.randint(5000, 6000),
+        "url": f"http://10.0.0.{random.randint(1,255)}:{random.randint(5000,6000)}",
+        "capabilities": caps,
+        "cpu_usage": random.uniform(10, 40),
+        "memory_usage": random.uniform(20, 60)
+    })
+    
+    return f"## 🆕 عقدة محاكاة\n**{node_id}** - {', '.join(caps)}\n\nتم التسجيل بنجاح!"
+
+def simulate_task_load(count: int):
+    """محاكاة حمل مهام"""
+    task_types = ['matrix', 'fibonacci', 'primes', 'data', 'image', 'general']
+    
+    for i in range(min(count, 10)):  # حد أقصى 10 مهام
+        task_type = random.choice(task_types)
+        central_server.submit_task({
+            "task_type": task_type,
+            "params": {"size": random.randint(10, 1000)},
+            "sender": "simulation",
+            "priority": random.randint(1, 3)
+        })
+        time.sleep(0.1)
+    
+    return f"## 📨 محاكاة حمل\nتم إرسال {min(count, 10)} مهام عشوائية!"
+
+# ─────────────── واجهة Gradio ───────────────
+def create_interface():
+    """إنشاء واجهة Gradio"""
+    
+    with gr.Blocks(
+        title="الخادم المركزي لتوزيع المهام",
+        theme=gr.themes.Soft(primary_hue="blue", secondary_hue="teal")
+    ) as demo:
+        gr.Markdown("# 🌐 الخادم المركزي الذكي لتوزيع المهام")
+        gr.Markdown("### نسخة Hugging Face Spaces - خادم حقيقي")
+        
+        with gr.Tabs():
+            # تبويب حالة النظام
+            with gr.TabItem("📊 لوحة التحكم"):
+                status_output = gr.Markdown()
+                refresh_btn = gr.Button("🔄 تحديث الحالة", variant="primary")
+                
+                refresh_btn.click(get_system_status, outputs=status_output)
+                demo.load(get_system_status, outputs=status_output)
+            
+            # تبويب إرسال المهام
+            with gr.TabItem("🚀 إرسال المهام"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### إرسال مهمة جديدة")
+                        
+                        task_type = gr.Dropdown(
+                            choices=[
+                                ("ضرب المصفوفات (CPU)", "matrix"),
+                                ("متسلسلة فيبوناتشي", "fibonacci"),
+                                ("الأعداد الأولية", "primes"),
+                                ("معالجة البيانات", "data"),
+                                ("محاكاة معالجة الصور", "image"),
+                                ("مهمة عامة", "general")
+                            ],
+                            label="نوع المهمة",
+                            value="matrix"
+                        )
+                        
+                        params_input = gr.Textbox(
+                            label="معاملات المهمة (JSON)",
+                            value='{"size": 100}',
+                            placeholder='{"size": 100} أو {"limit": 1000}'
+                        )
+                        
+                        submit_btn = gr.Button("📨 إرسال المهمة", variant="primary")
+                    
+                    with gr.Column():
+                        gr.Markdown("### نتيجة الإرسال")
+                        task_result = gr.Markdown()
+                
+                submit_btn.click(submit_task_ui, [task_type, params_input], task_result)
+            
+            # تبويب العقد
+            with gr.TabItem("👥 إدارة العقد"):
+                gr.Markdown("### العقد المتصلة")
+                nodes_table = gr.Dataframe(
+                    headers=["العقدة", "الحالة", "النقاط", "CPU%", "الذاكرة%", "المهام", "معدل النجاح", "آخر ظهور"],
+                    interactive=False,
+                    datatype=["str", "str", "str", "str", "str", "str", "str", "str"]
+                )
+                
+                with gr.Row():
+                    refresh_nodes = gr.Button("🔄 تحديث قائمة العقد")
+                    sim_node = gr.Button("➕ محاكاة عقدة جديدة")
+                    sim_tasks = gr.Button("📨 محاكاة حمل مهام")
+                    task_count = gr.Slider(1, 10, value=3, label="عدد المهام")
+                
+                sim_result = gr.Markdown()
+                
+                refresh_nodes.click(get_node_details, outputs=nodes_table)
+                sim_node.click(simulate_new_node, outputs=sim_result)
+                sim_tasks.click(simulate_task_load, task_count, sim_result)
+                demo.load(get_node_details, outputs=nodes_table)
+            
+            # تبويب المعلومات
+            with gr.TabItem("ℹ️ معلومات النظام"):
+                gr.Markdown("""
+                ## 📖 عن الخادم المركزي
+                
+                هذا تطبيق **خادم مركزي حقيقي** يعمل على Hugging Face Spaces.
+                
+                ### ✨ المميزات:
+                - **توزيع ذكي للمهام** على أفضل عقدة متاحة
+                - **مراقبة في الوقت الفعلي** لجميع العقد
+                - **محاكاة متقدمة** للعقد والمهام
+                - **إحصائيات مفصلة** عن أداء النظام
+                - **واجهة تحكم كاملة** عبر Gradio
+                
+                ### 🏗️ كيفية العمل:
+                1. **العقد تتصل** بالخادم وتسجل نفسها
+                2. **المهام ترسل** للخادم المركزي
+                3. **الخادم يختار** أفضل عقدة بناءً على:
+                   - استخدام CPU والذاكرة
+                   - معدل النجاح السابق
+                   - عدد المهام النشطة
+                   - وقت الاستجابة
+                4. **المهام تنفذ** على العقد المختارة
+                5. **النتائج ترجع** للخادم
+                
+                ### 🌐 API المتاح:
+                يمكن للعقد الحقيقية الاتصال عبر:
+                - `POST /register` - تسجيل عقدة
+                - `POST /task/submit` - إرسال مهمة
+                - `POST /status/update` - تحديث حالة
+                - `GET /nodes` - قائمة العقد
+                - `GET /tasks` - قائمة المهام
+                
+                ### 🔧 التقنيات:
+                - Python 3 مع معالجة متعددة الخيوط
+                - Gradio للواجهة الأمامية
+                - خوارزميات توزيع ذكية
+                - نظام محاكاة متكامل
+                """)
+        
+        gr.Markdown("---\n*الخادم المركزي لتوزيع المهام الذكي - الإصدار 3.0.0*")
+    
+    return demo
+
+# ─────────────── API Flask (للعقد الحقيقية) ───────────────
+flask_app = Flask(__name__)
+CORS(flask_app)
+
+@flask_app.route('/')
+def api_home():
+    return jsonify({
+        "message": "الخادم المركزي لتوزيع المهام",
+        "version": "3.0.0",
+        "status": "running",
+        "gradio_url": "https://huggingface.co/spaces/your-username/your-space"
+    })
+
+@flask_app.route('/register', methods=['POST'])
+def api_register():
+    try:
+        data = request.get_json()
+        result = central_server.register_node(data)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@flask_app.route('/task/submit', methods=['POST'])
+def api_submit_task():
+    try:
+        data = request.get_json()
+        result = central_server.submit_task(data)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@flask_app.route('/status/update', methods=['POST'])
+def api_update_status():
+    try:
+        data = request.get_json()
+        node_id = data.get('node_id')
+        if not node_id:
+            return jsonify({"error": "معرف العقدة مطلوب"}), 400
+        
+        result = central_server.update_node_status(node_id, data)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@flask_app.route('/nodes', methods=['GET'])
+def api_get_nodes():
+    try:
+        overview = central_server.get_system_overview()
+        return jsonify({
+            "status": "success",
+            "count": len(overview["nodes"]),
+            "nodes": overview["nodes"]
+        })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@flask_app.route('/tasks', methods=['GET'])
+def api_get_tasks():
+    try:
+        with central_server.lock:
+            tasks = list(central_server.tasks.values())[-50:]
+            tasks_data = []
+            for task in tasks:
+                task_dict = asdict(task)
+                for field in ["created_at", "started_at", "completed_at"]:
+                    if task_dict[field]:
+                        task_dict[field] = task_dict[field].isoformat()
+                tasks_data.append(task_dict)
+            
+            return jsonify({
+                "status": "success",
+                "count": len(tasks_data),
+                "tasks": tasks_data
+            })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@flask_app.route('/stats', methods=['GET'])
+def api_get_stats():
+    try:
+        overview = central_server.get_system_overview()
+        return jsonify({
+            "status": "success",
+            "stats": overview["metrics"]
+        })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# ─────────────── بدء Flask في خيط منفصل ───────────────
+def start_flask_server():
+    """بدء خادم Flask للعقد الحقيقية"""
+    port = 7861  # منفذ مختلف عن Gradio
+    flask_app.run(
+        host="0.0.0.0",
+        port=port,
+        debug=False,
+        threaded=True,
+        use_reloader=False
+    )
+
+# ─────────────── الدالة الرئيسية ───────────────
+def main():
+    """الدالة الرئيسية"""
+    logger.info("🚀 بدء تشغيل تطبيق Hugging Face كخادم مركزي")
+    
+    # بدء خادم Flask للAPI في خيط منفصل
+    flask_thread = threading.Thread(target=start_flask_server, daemon=True)
+    flask_thread.start()
+    logger.info("✅ بدء خادم Flask API على المنفذ 7861")
+    
+    # إنشاء واجهة Gradio
+    demo = create_interface()
+    
+    # تشغيل Gradio
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=False
+    )
 
 if __name__ == "__main__":
     # تشغيل FastAPI في thread منفصل