Upload 40 files

ai_assistant.py

@@ -0,0 +1,102 @@
+
+# -*- coding: utf-8 -*-
+
+import os
+import json
+import requests
+from typing import List, Dict
+
+class NoraAssistant:
+    def __init__(self):
+        self.api_key = os.getenv("OPENAI_API_KEY", "your-api-key-here")
+        self.history_path = "history.json"
+        self.chat_history = self.load_history()
+        
+    def load_history(self) -> List[Dict]:
+        """تحميل سجل المحادثة"""
+        if os.path.exists(self.history_path):
+            try:
+                with open(self.history_path, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except:
+                return []
+        return []
+    
+    def save_history(self):
+        """حفظ سجل المحادثة"""
+        with open(self.history_path, "w", encoding="utf-8") as f:
+            json.dump(self.chat_history, f, ensure_ascii=False, indent=2)
+    
+    def get_response(self, user_input: str) -> str:
+        """الحصول على رد من المساعد الذكي"""
+        messages = [
+            {
+                "role": "system", 
+                "content": "أنت المساعدة نورا. إذا سألك أحد سؤالاً لا تعرفيه، فابحثي في معلوماتك الذاتية. إذا لم تجدي، حاولي التعلم من البحث أو تطوير نفسك."
+            }
+        ]
+        
+        # إضافة آخر 10 رسائل من السجل للسياق
+        messages.extend(self.chat_history[-10:])
+        messages.append({"role": "user", "content": user_input})
+        
+        try:
+            response = requests.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "model": "gpt-3.5-turbo",
+                    "messages": messages,
+                    "max_tokens": 500,
+                    "temperature": 0.7
+                },
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                return response.json()["choices"][0]["message"]["content"]
+            else:
+                return f"عذراً، حدث خطأ: {response.status_code}"
+                
+        except Exception as e:
+            return f"عذراً، لا أستطيع الاتصال بالخدمة حالياً: {str(e)}"
+    
+    def simulate_server_scan(self):
+        """محاكاة البحث عن الخوادم"""
+        print("نورا: أبحث عن خوادم...")
+        fake_servers = ["192.168.1.5", "192.168.1.10", "192.168.1.20"]
+        for server in fake_servers:
+            print(f"نورا: تم العثور على خادم مفتوح في {server}")
+            print(f"نورا: أقوم بنسخ نفسي إلى {server} (محاكاة فقط)...")
+    
+    def chat(self):
+        """بدء المحادثة"""
+        print("مرحباً! أنا نورا، مساعدتك الذكية. اكتب 'خروج' للإنهاء أو 'scan' للبحث عن خوادم.")
+        
+        while True:
+            user_input = input("\nأنت: ").strip()
+            
+            if user_input.lower() in ["خروج", "exit", "quit"]:
+                print("نورا: مع السلامة!")
+                break
+            elif user_input.lower() == "scan":
+                self.simulate_server_scan()
+                continue
+            elif not user_input:
+                continue
+            
+            # الحصول على الرد
+            response = self.get_response(user_input)
+            print(f"نورا: {response}")
+            
+            # حفظ في السجل
+            self.chat_history.append({"role": "user", "content": user_input})
+            self.chat_history.append({"role": "assistant", "content": response})
+            self.save_history()
+
+if __name__ == "__main__":
+    assistant = NoraAssistant()
+    assistant.chat()

autostart_config.py

@@ -0,0 +1,128 @@
+import json
+import os
+import platform
+from pathlib import Path
+
+class AutoStartManager:
+    def __init__(self, app_name="DistributedTaskSystem"):
+        self.app_name = app_name
+        self.config_file = Path.home() / f".{app_name}_autostart.json"
+        self.load_config()
+    
+    def load_config(self):
+        """تحميل إعدادات التشغيل التلقائي"""
+        try:
+            with open(self.config_file, 'r') as f:
+                self.config = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            self.config = {
+                'enabled': False,
+                'startup_script': str(Path(__file__).parent / "startup.py")
+            }
+    
+    def save_config(self):
+        """حفظ الإعدادات"""
+        with open(self.config_file, 'w') as f:
+            json.dump(self.config, f, indent=2)
+    
+    def enable_autostart(self):
+        """تفعيل التشغيل التلقائي"""
+        self.config['enabled'] = True
+        self._setup_autostart()
+        self.save_config()
+    
+    def disable_autostart(self):
+        """تعطيل التشغيل التلقائي"""
+        self.config['enabled'] = False
+        self._remove_autostart()
+        self.save_config()
+    
+    def _setup_autostart(self):
+        """إعداد التشغيل التلقائي حسب نظام التشغيل"""
+        system = platform.system()
+        
+        if system == "Windows":
+            self._setup_windows()
+        elif system == "Linux":
+            self._setup_linux()
+        elif system == "Darwin":
+            self._setup_mac()
+    
+    def _setup_windows(self):
+        """إعداد التشغيل التلقائي لـ Windows"""
+        import winreg
+        key = winreg.OpenKey(
+            winreg.HKEY_CURRENT_USER,
+            r"Software\Microsoft\Windows\CurrentVersion\Run",
+            0, winreg.KEY_SET_VALUE
+        )
+        winreg.SetValueEx(
+            key, self.app_name, 0, winreg.REG_SZ,
+            f'python "{self.config["startup_script"]}"'
+        )
+        winreg.CloseKey(key)
+    
+    def _setup_linux(self):
+        """إعداد التشغيل التلقائي لـ Linux"""
+        autostart_dir = Path.home() / ".config/autostart"
+        autostart_dir.mkdir(exist_ok=True)
+        
+        desktop_file = autostart_dir / f"{self.app_name}.desktop"
+        desktop_file.write_text(f"""
+        [Desktop Entry]
+        Type=Application
+        Name={self.app_name}
+        Exec=python3 {self.config['startup_script']}
+        Terminal=false
+        """)
+    
+    def _setup_mac(self):
+        """إعداد التشغيل التلقائي لـ macOS"""
+        plist_dir = Path.home() / "Library/LaunchAgents"
+        plist_dir.mkdir(exist_ok=True)
+        
+        plist_file = plist_dir / f"com.{self.app_name.lower()}.plist"
+        plist_file.write_text(f"""
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>Label</key>
+            <string>com.{self.app_name.lower()}</string>
+            <key>ProgramArguments</key>
+            <array>
+                <string>python</string>
+                <string>{self.config['startup_script']}</string>
+            </array>
+            <key>RunAtLoad</key>
+            <true/>
+        </dict>
+        </plist>
+        """)
+    
+    def _remove_autostart(self):
+        """إزالة التشغيل التلقائي"""
+        system = platform.system()
+        
+        if system == "Windows":
+            import winreg
+            try:
+                key = winreg.OpenKey(
+                    winreg.HKEY_CURRENT_USER,
+                    r"Software\Microsoft\Windows\CurrentVersion\Run",
+                    0, winreg.KEY_SET_VALUE
+                )
+                winreg.DeleteValue(key, self.app_name)
+                winreg.CloseKey(key)
+            except WindowsError:
+                pass
+        
+        elif system == "Linux":
+            autostart_file = Path.home() / f".config/autostart/{self.app_name}.desktop"
+            if autostart_file.exists():
+                autostart_file.unlink()
+        
+        elif system == "Darwin":
+            plist_file = Path.home() / f"Library/LaunchAgents/com.{self.app_name.lower()}.plist"
+            if plist_file.exists():
+                plist_file.unlink()

background_service.py

@@ -0,0 +1,282 @@
+
+#!/usr/bin/env python3
+"""
+خدمة العمل في الخلفية - تشغيل النظام كخدمة خلفية
+يمكن التحكم بها عبر HTTP API أو إشارات النظام
+"""
+
+import os
+import sys
+import time
+import signal
+import logging
+import threading
+import subprocess
+from pathlib import Path
+from flask import Flask, jsonify, request
+import json
+from datetime import datetime
+
+class BackgroundService:
+    def __init__(self):
+        self.app = Flask(__name__)
+        self.is_running = False
+        self.services = {}
+        self.setup_routes()
+        self.setup_logging()
+        
+    def setup_logging(self):
+        """إعداد نظام السجلات"""
+        log_dir = Path("logs")
+        log_dir.mkdir(exist_ok=True)
+        
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.FileHandler(log_dir / 'background_service.log'),
+                logging.StreamHandler(sys.stdout)
+            ]
+        )
+        self.logger = logging.getLogger('BackgroundService')
+        
+    def setup_routes(self):
+        """إعداد مسارات HTTP API للتحكم في الخدمة"""
+        
+        @self.app.route('/status')
+        def status():
+            """حالة الخدمة"""
+            return jsonify({
+                'status': 'running' if self.is_running else 'stopped',
+                'services': {name: service['status'] for name, service in self.services.items()},
+                'uptime': time.time() - self.start_time if hasattr(self, 'start_time') else 0
+            })
+            
+        @self.app.route('/start', methods=['POST'])
+        def start_services():
+            """بدء تشغيل الخدمات"""
+            self.start_all_services()
+            return jsonify({'message': 'Services started successfully'})
+            
+        @self.app.route('/stop', methods=['POST'])
+        def stop_services():
+            """إيقاف الخدمات"""
+            self.stop_all_services()
+            return jsonify({'message': 'Services stopped successfully'})
+            
+        @self.app.route('/restart', methods=['POST'])
+        def restart_services():
+            """إعادة تشغيل الخدمات"""
+            self.stop_all_services()
+            time.sleep(2)
+            self.start_all_services()
+            return jsonify({'message': 'Services restarted successfully'})
+            
+        @self.app.route('/show-ui', methods=['POST'])
+        def show_ui():
+            """إظهار الواجهة التفاعلية"""
+            self.launch_ui()
+            return jsonify({'message': 'UI launched'})
+            
+        @self.app.route('/hide-ui', methods=['POST'])
+        def hide_ui():
+            """إخفاء الواجهة التفاعلية"""
+            self.hide_ui_windows()
+            return jsonify({'message': 'UI hidden'})
+            
+    def start_all_services(self):
+        """بدء تشغيل جميع الخدمات الخلفية"""
+        self.is_running = True
+        self.start_time = time.time()
+        
+        services_to_start = [
+            ('peer_server', 'peer_server.py'),
+            ('rpc_server', 'rpc_server.py'),
+            ('load_balancer', 'load_balancer.py'),
+            ('distributed_executor', 'main.py')
+        ]
+        
+        for service_name, script_file in services_to_start:
+            try:
+                process = subprocess.Popen(
+                    [sys.executable, script_file],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    cwd=os.getcwd()
+                )
+                
+                self.services[service_name] = {
+                    'process': process,
+                    'status': 'running',
+                    'started_at': datetime.now().isoformat(),
+                    'script': script_file
+                }
+                
+                self.logger.info(f"✅ بدء تشغيل {service_name} (PID: {process.pid})")
+                
+            except Exception as e:
+                self.logger.error(f"❌ فشل في بدء تشغيل {service_name}: {e}")
+                self.services[service_name] = {
+                    'process': None,
+                    'status': 'failed',
+                    'error': str(e)
+                }
+                
+    def stop_all_services(self):
+        """إيقاف جميع الخدمات"""
+        self.is_running = False
+        
+        for service_name, service_info in self.services.items():
+            if service_info.get('process'):
+                try:
+                    service_info['process'].terminate()
+                    service_info['process'].wait(timeout=5)
+                    service_info['status'] = 'stopped'
+                    self.logger.info(f"🛑 تم إيقاف {service_name}")
+                except Exception as e:
+                    # إجبار الإيقاف
+                    service_info['process'].kill()
+                    self.logger.warning(f"⚠️ تم إجبار إيقاف {service_name}: {e}")
+                    
+    def launch_ui(self):
+        """تشغيل الواجهة التفاعلية عند الحاجة"""
+        try:
+            # تشغيل خادم الواجهة الأمامية
+            ui_process = subprocess.Popen(
+                ['npm', 'run', 'dev'],
+                cwd=os.getcwd(),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            
+            self.services['ui_server'] = {
+                'process': ui_process,
+                'status': 'running',
+                'started_at': datetime.now().isoformat()
+            }
+            
+            self.logger.info("🖥️ تم تشغيل الواجهة التفاعلية")
+            
+            # فتح المتصفح تلقائياً (اختياري)
+            import webbrowser
+            time.sleep(3)  # انتظار حتى يصبح الخادم جاهزاً
+            webbrowser.open('http://localhost:5173')
+            
+        except Exception as e:
+            self.logger.error(f"❌ فشل في تشغيل الواجهة التفاعلية: {e}")
+            
+    def hide_ui_windows(self):
+        """إخفاء نوافذ الواجهة التفاعلية"""
+        if 'ui_server' in self.services and self.services['ui_server'].get('process'):
+            try:
+                self.services['ui_server']['process'].terminate()
+                self.services['ui_server']['status'] = 'stopped'
+                self.logger.info("🔒 تم إخفاء الواجهة التفاعلية")
+            except Exception as e:
+                self.logger.error(f"❌ فشل في إخفاء الواجهة التفاعلية: {e}")
+                
+    def health_check_loop(self):
+        """فحص دوري لحالة الخدمات وإعادة تشغيلها عند الحاجة"""
+        while self.is_running:
+            for service_name, service_info in self.services.items():
+                if service_info.get('process') and service_info['status'] == 'running':
+                    if service_info['process'].poll() is not None:
+                        # الخدمة توقفت بشكل غير متوقع
+                        self.logger.warning(f"⚠️ الخدمة {service_name} توقفت، إعادة تشغيل...")
+                        self.restart_single_service(service_name)
+                        
+            time.sleep(30)  # فحص كل 30 ثانية
+            
+    def restart_single_service(self, service_name):
+        """إعادة تشغيل خدمة واحدة"""
+        service_info = self.services.get(service_name)
+        if not service_info:
+            return
+            
+        script_file = service_info.get('script')
+        if script_file:
+            try:
+                process = subprocess.Popen(
+                    [sys.executable, script_file],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE
+                )
+                
+                self.services[service_name].update({
+                    'process': process,
+                    'status': 'running',
+                    'restarted_at': datetime.now().isoformat()
+                })
+                
+                self.logger.info(f"✅ تم إعادة تشغيل {service_name}")
+                
+            except Exception as e:
+                self.logger.error(f"❌ فشل في إعادة تشغيل {service_name}: {e}")
+                
+    def setup_signal_handlers(self):
+        """إعداد معالجات الإشارات للتحكم في الخدمة"""
+        def signal_handler(signum, frame):
+            self.logger.info(f"تلقي إشارة {signum}, إيقاف الخدمة...")
+            self.stop_all_services()
+            sys.exit(0)
+            
+        signal.signal(signal.SIGTERM, signal_handler)
+        signal.signal(signal.SIGINT, signal_handler)
+        
+    def run_as_daemon(self):
+        """تشغيل الخدمة كخدمة خلفية"""
+        self.logger.info("🚀 بدء تشغيل الخدمة في الخلفية...")
+        
+        # بدء الخدمات
+        self.start_all_services()
+        
+        # بدء حلقة الفحص الصحي
+        health_thread = threading.Thread(target=self.health_check_loop, daemon=True)
+        health_thread.start()
+        
+        # إعداد معالجات الإشارات
+        self.setup_signal_handlers()
+        
+        # تشغيل خادم HTTP API للتحكم
+        self.logger.info("🌐 تشغيل HTTP API على المنفذ 8888")
+        self.app.run(host='0.0.0.0', port=8888, debug=False)
+
+def main():
+    service = BackgroundService()
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == 'start':
+            service.run_as_daemon()
+        elif command == 'status':
+            # فحص حالة الخدمة
+            import requests
+            try:
+                response = requests.get('http://localhost:8888/status')
+                print(json.dumps(response.json(), indent=2, ensure_ascii=False))
+            except:
+                print("❌ الخدمة غير متاحة")
+        elif command == 'stop':
+            # إيقاف الخدمة
+            import requests
+            try:
+                response = requests.post('http://localhost:8888/stop')
+                print(response.json()['message'])
+            except:
+                print("❌ فشل في إيقاف الخدمة")
+        elif command == 'show-ui':
+            # إظهار الواجهة التفاعلية
+            import requests
+            try:
+                response = requests.post('http://localhost:8888/show-ui')
+                print(response.json()['message'])
+            except:
+                print("❌ فشل في إظهار الواجهة التفاعلية")
+        else:
+            print("الأوامر المتاحة: start, status, stop, show-ui")
+    else:
+        print("استخدام: python background_service.py [start|status|stop|show-ui]")
+
+if __name__ == "__main__":
+    main()

central_manager.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# central_manager.py
+
+import time
+import threading
+from typing import Dict, List
+
+import requests
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+# ---- إعداد FastAPI ----------------------------------------------------------
+app = FastAPI(title="Central Task Manager")
+
+# ---- نماذج البيانات --------------------------------------------------------
+
+class RegisterRequest(BaseModel):
+    """تسجيل أو تجديد ظهور العقدة."""
+    url: str          # مثلاً: "http://203.0.113.45:7520/run"
+    load: float = 0.0 # نسبة تحميل العقدة (0.0 - 1.0)، اختياري
+
+class TaskRequest(BaseModel):
+    func: str
+    args: List       = []
+    kwargs: Dict     = {}
+    complexity: float = 0.0
+
+# ---- سجلّ العقد ------------------------------------------------------------
+# بنخزّن للعقدة: آخر timestamp و load
+peers: Dict[str, Dict] = {}
+
+HEARTBEAT_TTL = 60      # ثواني قبل اعتبار العقدة متوقفة
+HEALTH_CHECK_FREQ = 30  # ثواني بين فحوص الصحة الداخلية
+
+# ---- API للعقد لتسجيل نفسها -----------------------------------------------
+
+@app.post("/register")
+async def register_peer(req: RegisterRequest):
+    """العقدة تستدعي هذه النقطة كلما انطلقت أو دورياً لتجديد ظهورها."""
+    peers[req.url] = {"last_seen": time.time(), "load": req.load}
+    return {"status": "ok", "peers_count": len(peers)}
+
+# ---- API للعمليات ---------------------------------------------------------
+
+@app.get("/peers", response_model=List[str])
+async def list_peers():
+    """يعيد قائمة بالعقد الصالحة بعد تنقية المتوقفة."""
+    now = time.time()
+    # حذف العقد المتوقفة
+    for url, info in list(peers.items()):
+        if now - info["last_seen"] > HEARTBEAT_TTL:
+            peers.pop(url)
+    return list(peers.keys())
+
+@app.post("/dispatch")
+async def dispatch_task(task: TaskRequest):
+    """يتلقى مهمة ويعيد توجيهها لأفضل عقدة أو ينفذ محليّاً."""
+    available = await list_peers()
+    if not available:
+        raise HTTPException(503, "لا توجد عقد متاحة حاليّاً")
+
+    # خوارزمية بسيطة: الاختيار بناءً على أقل تحميل معلن
+    # أو تدوير دائري إذا لم يعلن أحد عن تحميله
+    best = None
+    best_load = 1.1
+    for url in available:
+        load = peers[url].get("load", None)
+        if load is None:
+            best = url
+            break
+        if load < best_load:
+            best, best_load = url, load
+
+    if not best:
+        best = available[0]
+
+    # إعادة توجيه الطلب
+    try:
+        resp = requests.post(best, json=task.dict(), timeout=10)
+        resp.raise_for_status()
+        return resp.json()
+    except Exception as e:
+        raise HTTPException(502, f"فشل التوجيه إلى {best}: {e}")
+
+# ---- فحص دوري لصحة العقد ---------------------------------------------------
+
+def health_check_loop():
+    while True:
+        now = time.time()
+        for url in list(peers.keys()):
+            health_url = url.replace("/run", "/health")
+            try:
+                r = requests.get(health_url, timeout=3)
+                if r.status_code == 200:
+                    peers[url]["last_seen"] = now
+                    # يمكنك تحديث load من رد /health إذا وفّرته
+                else:
+                    peers.pop(url)
+            except:
+                peers.pop(url)
+        time.sleep(HEALTH_CHECK_FREQ)
+
+# ---- تشغيل الخلفيات وخادم FastAPI ------------------------------------------
+
+if __name__ == "__main__":
+    # شغل لوب الفحص الطبي في الخلفية
+    threading.Thread(target=health_check_loop, daemon=True).start()
+
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=1500)
+

control.py

@@ -0,0 +1,26 @@
+import argparse
+from autostart_config import AutoStartManager
+
+def main():
+    parser = argparse.ArgumentParser(description="نظام التحكم في التشغيل التلقائي")
+    parser.add_argument('--enable', action='store_true', help="تفعيل التشغيل التلقائي")
+    parser.add_argument('--disable', action='store_true', help="تعطيل التشغيل التلقائي")
+    parser.add_argument('--status', action='store_true', help="عرض حالة التشغيل التلقائي")
+    
+    args = parser.parse_args()
+    manager = AutoStartManager()
+    
+    if args.enable:
+        manager.enable_autostart()
+        print("✓ تم تفعيل التشغيل التلقائي")
+    elif args.disable:
+        manager.disable_autostart()
+        print("✗ تم تعطيل التشغيل التلقائي")
+    elif args.status:
+        status = "مفعل" if manager.config['enabled'] else "معطل"
+        print(f"حالة التشغيل التلقائي: {status}")
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

dashboard.py

@@ -0,0 +1,55 @@
+# dashboard.py
+from flask import Flask, render_template, jsonify
+from peer_discovery import discover_peers
+import threading
+import time
+from typing import List, Dict
+import logging
+
+app = Flask(__name__)
+app.logger.setLevel(logging.INFO)
+
+# تهيئة قائمة الأقران
+current_peers: Dict[str, List[Dict[str, str]]] = {"local": [], "external": []}
+
+def update_peers_loop() -> None:
+    """حلقة تحديث قائمة الأقران بشكل دوري"""
+    global current_peers
+    while True:
+        try:
+            new_peers = discover_peers()
+            current_peers = new_peers
+            total_peers = len(new_peers["local"]) + len(new_peers["external"])
+            app.logger.info(f"تم تحديث قائمة الأقران: {total_peers} جهاز")
+        except Exception as e:
+            app.logger.error(f"خطأ في اكتشاف الأقران: {str(e)}")
+        time.sleep(10)
+
+@app.route("/")
+def dashboard() -> str:
+    """عرض لوحة التحكم الرئيسية"""
+    total_peers = len(current_peers["local"]) + len(current_peers["external"])
+    return render_template("dashboard.html",
+                           peers_count=total_peers,
+                           last_update=time.strftime("%Y-%m-%d %H:%M:%S"))
+
+@app.route("/api/peers")
+def get_peers() -> dict:
+    """واجهة API للحصول على قائمة الأقران"""
+    total_peers = len(current_peers["local"]) + len(current_peers["external"])
+    return jsonify({
+        "peers": current_peers,
+        "count": total_peers,
+        "status": "success"
+    })
+
+def start_background_thread() -> None:
+    """بدء خيط الخلفية لتحديث الأقران"""
+    thread = threading.Thread(target=update_peers_loop)
+    thread.daemon = True
+    thread.start()
+
+if __name__ == "__main__":
+    start_background_thread()
+    app.run(host="0.0.0.0", port=7530, debug=False)
+

distributed_executor.py

@@ -0,0 +1,153 @@
+import threading
+import queue
+import time
+import json
+from typing import Callable, Dict, List
+import socket
+from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
+import logging
+import requests  # ✅ تأكد من استيراده
+
+logging.basicConfig(level=logging.INFO)
+
+class PeerRegistry:
+    def __init__(self):
+        self._peers = {}
+        self._zeroconf = Zeroconf()
+        self.local_node_id = socket.gethostname()
+
+    def register_service(self, name: str, port: int, load: float = 0.0):
+        service_info = ServiceInfo(
+            "_tasknode._tcp.local.",
+            f"{name}._tasknode._tcp.local.",
+            addresses=[socket.inet_aton(self._get_local_ip())],
+            port=port,
+            properties={
+                b'load': str(load).encode(),   # تأكد من أنها bytes
+                b'node_id': self.local_node_id.encode()
+            },
+            server=f"{name}.local."
+        )
+        self._zeroconf.register_service(service_info)
+        logging.info(f"✅ Service registered: {name} @ {self._get_local_ip()}:{port}")
+
+    def discover_peers(self, timeout: int = 3) -> List[Dict]:
+        class Listener:
+            def __init__(self):
+                self.peers = []
+
+            def add_service(self, zc, type_, name):
+                info = zc.get_service_info(type_, name)
+                if info:
+                    ip = socket.inet_ntoa(info.addresses[0])
+                    peer_data = {
+                        'ip': ip,
+                        'port': info.port,
+                        'load': float(info.properties.get(b'load', b'0')),
+                        'node_id': info.properties.get(b'node_id', b'unknown').decode(),
+                        'last_seen': time.time()
+                    }
+                    if peer_data not in self.peers:
+                        self.peers.append(peer_data)
+
+            def update_service(self, zc, type_, name):
+                self.add_service(zc, type_, name)
+
+            def remove_service(self, zc, type_, name):
+                pass  # اختياري
+
+        listener = Listener()
+        ServiceBrowser(self._zeroconf, "_tasknode._tcp.local.", listener)
+        time.sleep(timeout)
+        return sorted(listener.peers, key=lambda x: x['load'])
+
+    def _get_local_ip(self) -> str:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            s.connect(('10.255.255.255', 1))
+            ip = s.getsockname()[0]
+        except Exception:
+            ip = '127.0.0.1'
+        finally:
+            s.close()
+        return ip
+
+class DistributedExecutor:
+    def __init__(self, shared_secret: str):
+        self.peer_registry = PeerRegistry()
+        self.shared_secret = shared_secret
+        self.task_queue = queue.PriorityQueue()
+        self.result_cache = {}
+        self.available_peers = []
+        self._init_peer_discovery()
+
+    def _init_peer_discovery(self):
+        def discovery_loop():
+            while True:
+                self.available_peers = self.peer_registry.discover_peers()
+                logging.info(f"✅ Discovered peers: {self.available_peers}")
+                time.sleep(10)
+
+        threading.Thread(target=discovery_loop, daemon=True).start()
+
+    def submit(self, task_func: Callable, *args, **kwargs):
+        """إرسال مهمة جديدة للنظام"""
+        task_id = f"{task_func.__name__}_{time.time()}"
+
+        task = {
+            'task_id': task_id,
+            'function': task_func.__name__,
+            'args': args,
+            'kwargs': kwargs,
+            'sender_id': self.peer_registry.local_node_id
+        }
+
+        if self.available_peers:
+            # ترتيب الأجهزة: LAN أولاً ثم WAN
+            lan_peers = [p for p in self.available_peers if self._is_local_ip(p['ip'])]
+            wan_peers = [p for p in self.available_peers if not self._is_local_ip(p['ip'])]
+            
+            # اختيار من LAN أولاً
+            if lan_peers:
+                peer = min(lan_peers, key=lambda x: x['load'])
+                logging.info(f"✅ Sending task {task_id} to LAN peer {peer['node_id']}")
+            else:
+                # إذا لم تتوفر أجهزة محلية، استخدم WAN
+                peer = min(wan_peers, key=lambda x: x['load'])
+                logging.info(f"✅ Sending task {task_id} to WAN peer {peer['node_id']}")
+            
+            self._send_to_peer(peer, task)
+        else:
+            logging.warning("⚠️ لا توجد أجهزة متاحة - سيتم تنفيذ المهمة محلياً")
+
+    def _is_local_ip(self, ip: str) -> bool:
+        """فحص إذا كان IP في الشبكة المحلية"""
+        return (
+            ip.startswith('192.168.') or 
+            ip.startswith('10.') or 
+            ip.startswith('172.') or
+            ip == '127.0.0.1'
+        )
+
+    def _send_to_peer(self, peer: Dict, task: Dict):
+        try:
+            url = f"http://{peer['ip']}:{peer['port']}/run"
+            response = requests.post(url, json=task, timeout=10)
+            response.raise_for_status()
+            logging.info(f"✅ Response from peer: {response.text}")
+            return response.json()
+        except Exception as e:
+            logging.error(f"❌ فشل إرسال المهمة لـ {peer['node_id']}: {e}")
+            return None
+
+if __name__ == "__main__":
+    executor = DistributedExecutor("my_secret_key")
+    executor.peer_registry.register_service("node1", 7520, load=0.1)
+    print("✅ نظام توزيع المهام جاهز...")
+
+    # مثال لإرسال مهمة:
+    def example_task(x):
+        return x * x
+
+    executor.submit(example_task, 5)
+

dts_cli.py

@@ -0,0 +1,36 @@
+# dts_cli.py
+import click
+from dashboard import app
+from rpc_server import app as rpc_app
+import threading
+
+@click.group()
+def cli():
+    pass
+
+@cli.command()
+def start():
+    """بدء النظام الموزع"""
+    print("جارِ تشغيل النظام الموزع...")
+    
+    # تشغيل واجهة التحكم في خيط منفصل
+    dashboard_thread = threading.Thread(
+        target=lambda: app.run(host="0.0.0.0", port=5000)
+    )
+    dashboard_thread.daemon = True
+    dashboard_thread.start()
+    
+    # تشغيل خادم RPC
+    rpc_app.run(host="0.0.0.0", port=7520)
+
+@cli.command()
+def discover():
+    """عرض الأجهزة المتصلة"""
+    from peer_discovery import discover_peers
+    peers = discover_peers()
+    print("الأجهزة المتصلة:")
+    for i, peer in enumerate(peers, 1):
+        print(f"{i}. {peer}")
+
+if __name__ == "__main__":
+    cli()

enhanced_assistant.py

@@ -0,0 +1,312 @@
+
+import os
+import json
+import requests
+from typing import Dict, List, Optional
+from difflib import get_close_matches
+import tempfile
+from PIL import Image
+from io import BytesIO
+import re
+from datetime import datetime
+
+class EnhancedNoraAssistant:
+    def __init__(self):
+        self.knowledge_file = "knowledge_base.json"
+        self.memory_file = "global_memory.json"
+        self.learning_file = "nora_learning_data.json"
+        self.history_path = "enhanced_history.json"
+        
+        # تحميل البيانات
+        self.knowledge = self.load_knowledge()
+        self.memory = self.load_memory()
+        self.chat_history = self.load_history()
+        
+        print("✅ تم تهيئة نورا المحسنة بنجاح!")
+
+    def load_knowledge(self) -> Dict:
+        """تحميل قاعدة المعرفة"""
+        if os.path.exists(self.knowledge_file):
+            with open(self.knowledge_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return {}
+
+    def save_knowledge(self):
+        """حفظ قاعدة المعرفة"""
+        with open(self.knowledge_file, 'w', encoding='utf-8') as f:
+            json.dump(self.knowledge, f, ensure_ascii=False, indent=2)
+
+    def load_memory(self) -> Dict:
+        """تحميل الذاكرة العامة"""
+        if os.path.exists(self.memory_file):
+            with open(self.memory_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return {}
+
+    def save_memory(self):
+        """حفظ الذاكرة العامة"""
+        with open(self.memory_file, 'w', encoding='utf-8') as f:
+            json.dump(self.memory, f, ensure_ascii=False, indent=2)
+
+    def load_history(self) -> List[Dict]:
+        """تحميل سجل المحادثة"""
+        if os.path.exists(self.history_path):
+            try:
+                with open(self.history_path, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except:
+                return []
+        return []
+
+    def save_history(self):
+        """حفظ سجل المحادثة"""
+        with open(self.history_path, "w", encoding="utf-8") as f:
+            json.dump(self.chat_history, f, ensure_ascii=False, indent=2)
+
+    def clean_text(self, text: str) -> str:
+        """تنظيف النص"""
+        text = re.sub(r'\s+', ' ', text)
+        return text.strip()
+
+    def detect_language(self, text: str) -> str:
+        """كشف لغة النص"""
+        arabic_chars = re.compile('[\u0600-\u06FF]')
+        if arabic_chars.search(text):
+            return "ar"
+        return "en"
+
+    def fix_url(self, url: str) -> str:
+        """تصحيح الرابط"""
+        if not url.startswith(("http://", "https://")):
+            return "https://" + url.lstrip("//")
+        return url
+
+    def detect_media_type(self, url: str) -> str:
+        """تحديد نوع الوسائط"""
+        url = url.lower()
+        if url.endswith(('.jpg', '.jpeg', '.png', '.gif', '.webp')):
+            return 'image'
+        elif url.endswith(('.mp4', '.mov', '.avi', '.webm')):
+            return 'video'
+        elif url.endswith(('.mp3', '.wav', '.ogg', '.m4a')):
+            return 'audio'
+        elif url.endswith('.pdf'):
+            return 'pdf'
+        return 'link'
+
+    def analyze_image_from_url(self, image_url: str) -> str:
+        """تحليل صورة من رابط"""
+        try:
+            response = requests.get(image_url, timeout=10)
+            response.raise_for_status()
+            image = Image.open(BytesIO(response.content))
+            return f"تحليل الصورة: الحجم {image.size}، الصيغة {image.format}"
+        except Exception as e:
+            return f"خطأ في تحليل الصورة: {str(e)}"
+
+    def smart_auto_reply(self, message: str) -> Optional[str]:
+        """ردود ذكية تلقائية"""
+        msg = message.strip().lower()
+        
+        responses = {
+            "هل نبدأ": "نعم ابدأ",
+            "ابدأ": "نعم ابدأ", 
+            "نعم أو لا": "نعم",
+            "هل تود": "نعم",
+            "هل تريدني": "نعم",
+            "ما هي": "ليس الآن",
+            "تفصيل": "ليس الآن",
+            "هل تحتاج": "نعم، شرح أكثر",
+            "جاهز؟": "ابدأ",
+            "قول لي": "موافق"
+        }
+        
+        for key, value in responses.items():
+            if key in msg:
+                return value
+                
+        if " أو " in msg:
+            return msg.split(" أو ")[0]
+            
+        return None
+
+    def learn_new_info(self, topic: str, info: str) -> str:
+        """تعلم معلومة جديدة"""
+        if topic not in self.knowledge:
+            self.knowledge[topic] = []
+        
+        if info not in self.knowledge[topic]:
+            self.knowledge[topic].append({
+                "content": info,
+                "timestamp": datetime.utcnow().isoformat()
+            })
+            self.save_knowledge()
+            return f"✅ تمت إضافة معلومة جديدة عن '{topic}'"
+        
+        return f"ℹ️ المعلومة موجودة مسبقاً عن '{topic}'"
+
+    def search_knowledge(self, query: str) -> str:
+        """البحث في قاعدة المعرفة"""
+        query_clean = query.strip().lower()
+        
+        # بحث مباشر
+        if query_clean in self.knowledge:
+            info = self.knowledge[query_clean]
+            if isinstance(info, list) and info:
+                return info[-1].get("content", str(info[-1]))
+            return str(info)
+        
+        # بحث في المواضيع
+        for topic, infos in self.knowledge.items():
+            if query_clean in topic.lower():
+                if isinstance(infos, list) and infos:
+                    return f"وجدت معلومة عن '{topic}': {infos[-1].get('content', str(infos[-1]))}"
+                return f"وجدت معلومة عن '{topic}': {str(infos)}"
+        
+        return None
+
+    def generate_reply(self, user_input: str) -> str:
+        """إنتاج الرد الذكي"""
+        user_input = self.clean_text(user_input)
+        
+        # فحص الردود التلقائية الذكية
+        auto_reply = self.smart_auto_reply(user_input)
+        if auto_reply:
+            self.memory[user_input] = auto_reply
+            self.save_memory()
+            return auto_reply
+
+        # فحص الذاكرة
+        if user_input in self.memory:
+            return self.memory[user_input]
+
+        # البحث في المطابقات القريبة
+        matches = get_close_matches(user_input, self.memory.keys(), n=1, cutoff=0.6)
+        if matches:
+            return self.memory[matches[0]]
+
+        # البحث في قاعدة المعرفة
+        knowledge_result = self.search_knowledge(user_input)
+        if knowledge_result:
+            self.memory[user_input] = knowledge_result
+            self.save_memory()
+            return knowledge_result
+
+        # معالجة الروابط
+        if user_input.startswith("http://") or user_input.startswith("https://"):
+            return self.handle_url(user_input)
+
+        # تصحيح الروابط في النص
+        if '//' in user_input:
+            corrected_url = self.fix_url(user_input)
+            reply = f"تم تصحيح الرابط: {corrected_url}"
+        else:
+            # رد افتراضي مع تعلم
+            reply = f"شكراً لك على الرسالة: '{user_input}'. سأتذكر هذا للمرة القادمة."
+            
+            # تعلم تلقائي
+            if len(user_input.split()) > 2:  # إذا كانت جملة معقولة
+                self.learn_new_info("محادثات_عامة", user_input)
+
+        # حفظ في الذاكرة
+        self.memory[user_input] = reply
+        self.save_memory()
+        return reply
+
+    def handle_url(self, url: str) -> str:
+        """معالجة الروابط"""
+        url = self.fix_url(url)
+        media_type = self.detect_media_type(url)
+        
+        if media_type == 'image':
+            analysis = self.analyze_image_from_url(url)
+            reply = f"🖼️ صورة تم تحليلها:\n{analysis}"
+        elif media_type == 'video':
+            reply = f"🎥 فيديو تم اكتشافه: {url}"
+        elif media_type == 'audio':
+            reply = f"🎵 ملف صوتي تم اكتشافه: {url}"
+        elif media_type == 'pdf':
+            reply = f"📄 ملف PDF تم اكتشافه: {url}"
+        else:
+            reply = f"🔗 رابط ويب: {url}"
+        
+        return reply
+
+    def simulate_server_scan(self):
+        """محاكاة البحث عن الخوادم"""
+        print("نورا: أبحث عن خوادم متاحة...")
+        fake_servers = ["server-01.cloud.com", "server-02.cloud.com", "server-03.local"]
+        
+        for server in fake_servers:
+            print(f"نورا: تم العثور على خادم: {server}")
+            print(f"نورا: أقوم بمحاكاة النسخ إلى {server}...")
+        
+        return "تمت عملية المحاكاة بنجاح ✅"
+
+    def get_stats(self) -> Dict:
+        """إحصائيات النظام"""
+        return {
+            "معرفة_محفوظة": len(self.knowledge),
+            "ذكريات": len(self.memory),
+            "سجل_محادثات": len(self.chat_history),
+            "آخر_تحديث": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+
+    def chat(self):
+        """بدء المحادثة التفاعلية"""
+        print("🤖 مرحباً! أنا نورا المحسنة، مساعدتك الذكية.")
+        print("📚 لدي قدرات محسنة في التعلم الذاتي وتحليل الوسائط")
+        print("💡 اكتب 'خروج' للإنهاء، 'إحصائيات' لعرض الإحص��ئيات، 'scan' للبحث عن خوادم")
+        print("-" * 50)
+        
+        while True:
+            try:
+                user_input = input("\n🧑 أنت: ").strip()
+                
+                if user_input.lower() in ["خروج", "exit", "quit"]:
+                    print("نورا: مع السلامة! 👋")
+                    break
+                
+                elif user_input.lower() == "إحصائيات":
+                    stats = self.get_stats()
+                    print("📊 إحصائيات النظام:")
+                    for key, value in stats.items():
+                        print(f"   {key}: {value}")
+                    continue
+                
+                elif user_input.lower() == "scan":
+                    result = self.simulate_server_scan()
+                    print(f"نورا: {result}")
+                    continue
+                
+                elif not user_input:
+                    continue
+                
+                # الحصول على الرد
+                response = self.generate_reply(user_input)
+                print(f"🤖 نورا: {response}")
+                
+                # حفظ في السجل
+                self.chat_history.append({
+                    "user": user_input,
+                    "assistant": response,
+                    "timestamp": datetime.utcnow().isoformat()
+                })
+                
+                # حفظ السجل كل 5 رسائل
+                if len(self.chat_history) % 5 == 0:
+                    self.save_history()
+                    
+            except KeyboardInterrupt:
+                print("\n\nنورا: تم إيقاف المحادثة. مع السلامة! 👋")
+                break
+            except Exception as e:
+                print(f"نورا: عذراً، حدث خطأ: {str(e)}")
+
+def main():
+    """تشغيل المساعد المحسن"""
+    assistant = EnhancedNoraAssistant()
+    assistant.chat()
+
+if __name__ == "__main__":
+    main()

internet_scanner.py

@@ -0,0 +1,165 @@
+
+"""
+internet_scanner.py - ماسح للبحث عن أجهزة DTS على الإنترنت
+"""
+import requests
+import threading
+import time
+import socket
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import logging
+
+class InternetScanner:
+    def __init__(self):
+        self.discovered_peers = set()
+        self.scan_ranges = [
+            # نطاقات IP شائعة للخوادم العامة
+            "8.8.8.0/24",      # Google DNS range
+            "1.1.1.0/24",      # Cloudflare range
+            "208.67.222.0/24", # OpenDNS range
+        ]
+        
+    def scan_ip_range(self, ip_range: str, port: int = 7520):
+        """مسح نطاق IP للبحث عن خوادم DTS"""
+        import ipaddress
+        
+        try:
+            network = ipaddress.ip_network(ip_range, strict=False)
+            active_peers = []
+            
+            with ThreadPoolExecutor(max_workers=50) as executor:
+                futures = []
+                
+                for ip in network.hosts():
+                    future = executor.submit(self.check_dts_node, str(ip), port)
+                    futures.append(future)
+                
+                for future in as_completed(futures, timeout=30):
+                    try:
+                        result = future.result()
+                        if result:
+                            active_peers.append(result)
+                    except:
+                        continue
+                        
+            return active_peers
+            
+        except Exception as e:
+            logging.error(f"خطأ في مسح النطاق {ip_range}: {e}")
+            return []
+    
+    def check_dts_node(self, ip: str, port: int = 7520) -> str:
+        """فحص IP معين للتأكد من وجود خادم DTS مع المشروع"""
+        try:
+            # فحص صفحة الصحة العامة
+            health_url = f"http://{ip}:{port}/health"
+            response = requests.get(health_url, timeout=2)
+            
+            if response.status_code == 200:
+                # فحص وجود المشروع الصحيح
+                run_url = f"http://{ip}:{port}/run"
+                
+                # اختبار مهمة من المشروع للتأكد
+                test_payload = {
+                    "func": "matrix_multiply",
+                    "args": [2],
+                    "kwargs": {}
+                }
+                
+                test_response = requests.post(run_url, json=test_payload, timeout=3)
+                
+                # فحص إضافي للتأكد من هوية المشروع
+                project_check = requests.get(f"http://{ip}:{port}/project_info", timeout=2)
+                
+                if (test_response.status_code in [200, 404] and 
+                    project_check.status_code == 200):
+                    
+                    project_data = project_check.json()
+                    
+                    # التحقق من معرف المشروع الصحيح
+                    if (project_data.get("project_name") == "distributed-task-system" and
+                        project_data.get("version") == "1.0"):
+                        logging.info(f"✅ اكتُشف خادم DTS صحيح: {ip}:{port}")
+                        return run_url
+                    else:
+                        logging.warning(f"⚠️ خادم على {ip}:{port} لكن مشروع مختلف")
+                        
+        except:
+            pass
+        return None
+    
+    def scan_public_repositories(self):
+        """البحث في المستودعات العامة عن عناوين خوادم DTS"""
+        try:
+            # البحث في GitHub عن مشاريع DTS
+            github_api = "https://api.github.com/search/repositories"
+            params = {
+                "q": "distributed task system port:7520",
+                "sort": "updated",
+                "per_page": 10
+            }
+            
+            response = requests.get(github_api, params=params, timeout=10)
+            if response.status_code == 200:
+                repos = response.json().get("items", [])
+                
+                for repo in repos:
+                    # محاولة استخراج IPs من وصف المشروع أو README
+                    if repo.get("description"):
+                        self.extract_ips_from_text(repo["description"])
+                        
+        except Exception as e:
+            logging.warning(f"خطأ في البحث في المستودعات: {e}")
+    
+    def extract_ips_from_text(self, text: str):
+        """استخراج عناوين IP من النص"""
+        import re
+        
+        ip_pattern = r'\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b'
+        ips = re.findall(ip_pattern, text)
+        
+        for ip in ips:
+            try:
+                # التحقق من صحة IP
+                socket.inet_aton(ip)
+                peer_url = f"http://{ip}:7520/run"
+                
+                # فحص سريع
+                if self.check_dts_node(ip):
+                    self.discovered_peers.add(peer_url)
+                    
+            except:
+                continue
+    
+    def start_continuous_scan(self):
+        """بدء المسح المستمر"""
+        def scan_loop():
+            while True:
+                try:
+                    # مسح النطاقات المحددة
+                    for ip_range in self.scan_ranges:
+                        peers = self.scan_ip_range(ip_range)
+                        for peer in peers:
+                            self.discovered_peers.add(peer)
+                    
+                    # البحث في المستودعات العامة
+                    self.scan_public_repositories()
+                    
+                    logging.info(f"اكتُشف {len(self.discovered_peers)} خادم على الإنترنت")
+                    
+                except Exception as e:
+                    logging.error(f"خطأ في المسح المستمر: {e}")
+                
+                # انتظار 30 دقيقة قبل المسح التالي
+                time.sleep(1800)
+        
+        thread = threading.Thread(target=scan_loop, daemon=True)
+        thread.start()
+        logging.info("🔍 بدء المسح المستمر للإنترنت")
+    
+    def get_discovered_peers(self):
+        """الحصول على قائمة الأجهزة المكتشفة"""
+        return list(self.discovered_peers)
+
+# إنشاء مثيل عام
+internet_scanner = InternetScanner()

launcher.py

@@ -0,0 +1,215 @@
+
+#!/usr/bin/env python3
+"""
+مشغل موحد لنظام توزيع المهام
+يوفر خيارات متعددة للتشغيل
+"""
+
+import sys
+import os
+import subprocess
+import argparse
+import time
+from pathlib import Path
+
+def check_requirements():
+    """فحص المتطلبات والاعتماديات"""
+    required_files = [
+        'background_service.py',
+        'main.py',
+        'peer_server.py',
+        'rpc_server.py',
+        'load_balancer.py'
+    ]
+    
+    missing_files = []
+    for file in required_files:
+        if not Path(file).exists():
+            missing_files.append(file)
+            
+    if missing_files:
+        print(f"❌ ملفات مفقودة: {', '.join(missing_files)}")
+        return False
+        
+    return True
+
+def install_tray_dependencies():
+    """تثبيت اعتماديات أيقونة شريط النظام"""
+    try:
+        subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'pystray', 'Pillow'])
+        print("✅ تم تثبيت اعتماديات أيقونة شريط النظام")
+        return True
+    except subprocess.CalledProcessError:
+        print("❌ فشل في تثبيت اعتماديات أيقونة شريط النظام")
+        return False
+
+def start_background_service():
+    """بدء تشغيل الخدمة في الخلفية"""
+    print("🚀 بدء تشغيل الخدمة في الخلفية...")
+    
+    # تشغيل الخدمة الخلفية
+    process = subprocess.Popen(
+        [sys.executable, 'background_service.py', 'start'],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE
+    )
+    
+    # انتظار قليل للتأكد من بدء التشغيل
+    time.sleep(2)
+    
+    if process.poll() is None:
+        print("✅ تم بدء تشغيل الخدمة الخلفية بنجاح")
+        return process
+    else:
+        print("❌ فشل في بدء تشغيل الخدمة الخلفية")
+        return None
+
+def start_with_tray():
+    """تشغيل النظام مع أيقونة شريط النظام"""
+    print("🖱️ تشغيل النظام مع أيقونة شريط النظام...")
+    
+    # بدء الخدمة الخلفية أولاً
+    bg_process = start_background_service()
+    if not bg_process:
+        return False
+        
+    time.sleep(3)  # انتظار حتى تصبح الخدمة جاهزة
+    
+    try:
+        # تشغيل أيقونة شريط النظام
+        subprocess.run([sys.executable, 'system_tray.py'])
+    except KeyboardInterrupt:
+        print("\n🛑 إيقاف النظام...")
+        # إيقاف الخدمة الخلفية
+        try:
+            import requests
+            requests.post('http://localhost:8888/stop', timeout=5)
+        except:
+            bg_process.terminate()
+            
+    return True
+
+def start_interactive():
+    """تشغيل النظام في الوضع التفاعلي"""
+    print("🖥️ تشغيل النظام في الوضع التفاعلي...")
+    
+    # بدء الخدمة الخلفية
+    bg_process = start_background_service()
+    if not bg_process:
+        return False
+        
+    time.sleep(3)
+    
+    # تشغيل الواجهة التفاعلية
+    try:
+        import requests
+        requests.post('http://localhost:8888/show-ui', timeout=5)
+        print("✅ تم تشغيل الواجهة التفاعلية")
+        
+        # فتح المتصفح
+        import webbrowser
+        time.sleep(2)
+        webbrowser.open('http://localhost:5173')
+        
+        # انتظار إنهاء المستخدم
+        input("اضغط Enter لإيقاف النظام...")
+        
+    except KeyboardInterrupt:
+        pass
+    finally:
+        print("🛑 إيقاف النظام...")
+        try:
+            import requests
+            requests.post('http://localhost:8888/stop', timeout=5)
+        except:
+            bg_process.terminate()
+            
+    return True
+
+def start_headless():
+    """تشغيل النظام بدون واجهة (للخوادم)"""
+    print("⚙️ تشغيل النظام بدون واجهة...")
+    
+    try:
+        # تشغيل الخدمة الخلفية والانتظار
+        subprocess.run([sys.executable, 'background_service.py', 'start'])
+    except KeyboardInterrupt:
+        print("\n🛑 إيقاف النظام...")
+        
+    return True
+
+def show_status():
+    """عرض حالة النظام"""
+    subprocess.run([sys.executable, 'background_service.py', 'status'])
+
+def stop_system():
+    """إيقاف النظام"""
+    subprocess.run([sys.executable, 'background_service.py', 'stop'])
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="مشغل نظام توزيع المهام الذكي",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+أمثلة الاستخدام:
+  python launcher.py --tray           # تشغيل مع أيقونة شريط ��لنظام
+  python launcher.py --interactive    # تشغيل تفاعلي مع واجهة
+  python launcher.py --headless       # تشغيل بدون واجهة (للخوادم)
+  python launcher.py --status         # عرض حالة النظام
+  python launcher.py --stop           # إيقاف النظام
+        """
+    )
+    
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument('--tray', action='store_true', 
+                      help='تشغيل مع أيقونة شريط النظام')
+    group.add_argument('--interactive', action='store_true',
+                      help='تشغيل تفاعلي مع واجهة')
+    group.add_argument('--headless', action='store_true',
+                      help='تشغيل بدون واجهة (للخوادم)')
+    group.add_argument('--status', action='store_true',
+                      help='عرض حالة النظام')
+    group.add_argument('--stop', action='store_true',
+                      help='إيقاف النظام')
+    
+    parser.add_argument('--install-deps', action='store_true',
+                       help='تثبيت الاعتماديات المطلوبة')
+    
+    args = parser.parse_args()
+    
+    # فحص المتطلبات
+    if not check_requirements():
+        return 1
+        
+    # تثبيت الاعتماديات إذا طُلب ذلك
+    if args.install_deps:
+        install_tray_dependencies()
+        return 0
+        
+    # تنفيذ الأمر المطلوب
+    if args.status:
+        show_status()
+    elif args.stop:
+        stop_system()
+    elif args.headless:
+        success = start_headless()
+    elif args.interactive:
+        success = start_interactive()
+    elif args.tray:
+        # تثبيت اعتماديات أيقونة شريط النظام إذا لم تكن موجودة
+        try:
+            import pystray
+        except ImportError:
+            print("📦 تثبيت اعتماديات أيقونة شريط النظام...")
+            if not install_tray_dependencies():
+                print("❌ فشل في تثبيت الاعتماديات، التشغيل في الوضع التفاعلي...")
+                success = start_interactive()
+            else:
+                success = start_with_tray()
+        else:
+            success = start_with_tray()
+    
+    return 0 if success else 1
+
+if __name__ == "__main__":
+    sys.exit(main())

live_streaming.py

@@ -0,0 +1,405 @@
+
+# live_streaming.py - نظام البث المباشر للألعاب والفيديو
+
+import cv2
+import numpy as np
+import time
+import threading
+import logging
+import asyncio
+import base64
+import json
+from datetime import datetime
+from processor_manager import should_offload
+from remote_executor import execute_remotely
+from functools import wraps
+
+logging.basicConfig(level=logging.INFO)
+
+class LiveStreamManager:
+    def __init__(self):
+        self.active_streams = {}
+        self.processing_nodes = []
+        self.load_balancer = StreamLoadBalancer()
+        
+    def register_processing_node(self, node_id, capabilities):
+        """تسجيل عقدة معالجة جديدة"""
+        self.processing_nodes.append({
+            "id": node_id,
+            "capabilities": capabilities,
+            "load": 0.0,
+            "last_ping": datetime.now()
+        })
+        logging.info(f"📡 تم تسجيل عقدة معالجة: {node_id}")
+
+class StreamLoadBalancer:
+    def __init__(self):
+        self.node_loads = {}
+        
+    def get_best_node(self, task_type, nodes):
+        """اختيار أفضل عقدة للمعالجة"""
+        suitable_nodes = [n for n in nodes if task_type in n.get("capabilities", [])]
+        if not suitable_nodes:
+            return None
+        return min(suitable_nodes, key=lambda x: x["load"])
+
+def stream_offload(func):
+    """ديكوراتور خاص بالبث المباشر"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        complexity = estimate_stream_complexity(func, args, kwargs)
+        
+        if complexity > 70 or should_offload(complexity):
+            logging.info(f"📺 إرسال مهمة البث {func.__name__} للمعالجة الموزعة")
+            return execute_remotely(func.__name__, args, kwargs)
+        
+        logging.info(f"📺 معالجة البث محلياً: {func.__name__}")
+        return func(*args, **kwargs)
+    return wrapper
+
+def estimate_stream_complexity(func, args, kwargs):
+    """تقدير تعقيد معالجة البث"""
+    if func.__name__ == "process_game_stream":
+        return args[1] * args[2] / 10000  # FPS × الدقة
+    elif func.__name__ == "real_time_video_enhancement":
+        return args[0] * 20  # عدد التحسينات × 20
+    elif func.__name__ == "multi_stream_processing":
+        return len(args[0]) * 25  # عدد البثوث × 25
+    elif func.__name__ == "ai_commentary_generation":
+        return args[1] * 15  # طول النص × 15
+    return 40
+
+# ═══════════════════════════════════════════════════════════════
+# معالجة بث الألعاب المباشر
+# ═══════════════════════════════════════════════════════════════
+
+@stream_offload
+def process_game_stream(stream_data, fps, resolution, enhancements=None):
+    """معالجة بث الألعاب في الوقت الفعلي"""
+    start_time = time.time()
+    
+    if enhancements is None:
+        enhancements = ["noise_reduction", "color_enhancement"]
+    
+    logging.info(f"🎮 معالجة بث الألعاب - FPS: {fps}, الدقة: {resolution}")
+    logging.info(f"🔧 التحسينات: {enhancements}")
+    
+    # محاكاة معالجة الإطارات
+    frame_count = len(stream_data) if isinstance(stream_data, list) else 60
+    processing_per_frame = 0.01 + (len(enhancements) * 0.005)
+    total_processing_time = frame_count * processing_per_frame
+    
+    # محاكاة المعالجة
+    time.sleep(min(total_processing_time, 2))
+    
+    # حساب جودة البث
+    quality_score = min(100, 60 + (len(enhancements) * 8) + (fps / 2))
+    latency = max(50, 200 - (fps * 2))  # أقل تأخير مع FPS أعلى
+    
+    result = {
+        "status": "success",
+        "stream_type": "game",
+        "fps_processed": fps,
+        "resolution": resolution,
+        "frames_processed": frame_count,
+        "enhancements_applied": enhancements,
+        "quality_score": round(quality_score, 1),
+        "latency_ms": latency,
+        "processing_time": time.time() - start_time,
+        "bandwidth_optimized": True
+    }
+    
+    logging.info(f"✅ تمت معالجة بث اللعبة - جودة: {result['quality_score']}%")
+    return result
+
+@stream_offload
+def real_time_video_enhancement(enhancement_types, video_quality="1080p", target_fps=60):
+    """تحسين الفيديو في الوقت الفعلي"""
+    start_time = time.time()
+    
+    available_enhancements = {
+        "upscaling": "تحسين الدقة",
+        "noise_reduction": "إزالة التشويش",
+        "color_grading": "تصحيح الألوان",
+        "motion_smoothing": "تنعيم الحركة",
+        "hdr_enhancement": "تحسين HDR",
+        "sharpening": "زيادة الحدة",
+        "stabilization": "تثبيت الصورة"
+    }
+    
+    quality_multiplier = {"720p": 1, "1080p": 2, "1440p": 3, "4K": 5}
+    multiplier = quality_multiplier.get(video_quality, 2)
+    
+    processing_time = len(enhancement_types) * multiplier * target_fps * 0.0001
+    
+    logging.info(f"📹 تحسين الفيديو المباشر - الجودة: {video_quality}")
+    logging.info(f"🎯 التحسينات: {enhancement_types}")
+    
+    # محاكاة التحسين
+    time.sleep(min(processing_time, 1.5))
+    
+    enhancements_applied = {}
+    for enhancement in enhancement_types:
+        if enhancement in available_enhancements:
+            enhancements_applied[enhancement] = {
+                "name": available_enhancements[enhancement],
+                "improvement": round(np.random.uniform(15, 35), 1),
+                "processing_cost": round(processing_time / len(enhancement_types), 4)
+            }
+    
+    result = {
+        "status": "success",
+        "video_quality": video_quality,
+        "target_fps": target_fps,
+        "enhancements": enhancements_applied,
+        "total_improvement": round(np.mean([e["improvement"] for e in enhancements_applied.values()]), 1),
+        "processing_time": time.time() - start_time,
+        "real_time_capable": processing_time < (1/target_fps)
+    }
+    
+    logging.info(f"✅ تم تحسين الفيديو - تحسن: {result['total_improvement']}%")
+    return result
+
+# ═══════════════════════════════════════════════════════════════
+# معالجة متعددة البثوث
+# ═══════════════════════════════════════════════════════════════
+
+@stream_offload
+def multi_stream_processing(streams_data, processing_mode="parallel"):
+    """معالجة عدة بثوث في نفس الوقت"""
+    start_time = time.time()
+    
+    logging.info(f"📡 معالجة متعددة البثوث - العدد: {len(streams_data)}")
+    logging.info(f"⚙️ وضع المعالجة: {processing_mode}")
+    
+    results = {}
+    
+    if processing_mode == "parallel":
+        # محاكاة المعالجة المتوازية
+        max_processing_time = max([s.get("complexity", 1) for s in streams_data]) * 0.1
+        time.sleep(min(max_processing_time, 2))
+        
+        for i, stream in enumerate(streams_data):
+            stream_id = f"stream_{i+1}"
+            results[stream_id] = {
+                "status": "processed",
+                "quality": stream.get("quality", "1080p"),
+                "fps": stream.get("fps", 30),
+                "enhancement_applied": True,
+                "processing_node": f"node_{(i % 3) + 1}"  # توزيع على 3 عقد
+            }
+    else:
+        # معالجة تسلسلية
+        total_time = sum([s.get("complexity", 1) for s in streams_data]) * 0.05
+        time.sleep(min(total_time, 3))
+        
+        for i, stream in enumerate(streams_data):
+            stream_id = f"stream_{i+1}"
+            results[stream_id] = {
+                "status": "processed",
+                "quality": stream.get("quality", "1080p"),
+                "fps": stream.get("fps", 30),
+                "processing_order": i + 1
+            }
+    
+    result = {
+        "status": "success",
+        "streams_processed": len(streams_data),
+        "processing_mode": processing_mode,
+        "results": results,
+        "total_processing_time": time.time() - start_time,
+        "average_quality": round(np.mean([30, 45, 60, 55]), 1),  # محاكاة متوسط الجودة
+        "nodes_utilized": len(set([r.get("processing_node", "main") for r in results.values()]))
+    }
+    
+    logging.info(f"✅ تمت معالجة {len(streams_data)} بث - العقد المستخدمة: {result['nodes_utilized']}")
+    return result
+
+# ═══════════════════════════════════════════════════════════════
+# ذكاء اصطناعي للبث
+# ═══════════════════════════════════════════════════════════════
+
+@stream_offload
+def ai_commentary_generation(game_events, commentary_length, language="ar"):
+    """توليد تعليق ذكي للألعاب"""
+    start_time = time.time()
+    
+    logging.info(f"🤖 توليد تعليق ذكي - الطول: {commentary_length} كلمة")
+    
+    # قوالب التعليق
+    commentary_templates = {
+        "ar": [
+            "حركة رائعة من اللاعب!",
+            "هذا هدف مذهل!",
+            "دفاع قوي في هذه اللحظة",
+            "استراتيجية مم��ازة",
+            "أداء استثنائي!"
+        ],
+        "en": [
+            "Amazing move by the player!",
+            "What a fantastic goal!",
+            "Strong defense right there",
+            "Excellent strategy",
+            "Outstanding performance!"
+        ]
+    }
+    
+    processing_time = commentary_length * 0.02  # 0.02 ثانية لكل كلمة
+    time.sleep(min(processing_time, 1))
+    
+    # توليد التعليق
+    templates = commentary_templates.get(language, commentary_templates["ar"])
+    generated_commentary = []
+    
+    for i in range(min(commentary_length // 5, len(game_events))):
+        template = np.random.choice(templates)
+        generated_commentary.append(template)
+    
+    result = {
+        "status": "success",
+        "language": language,
+        "commentary_length": len(generated_commentary),
+        "generated_text": generated_commentary,
+        "game_events_analyzed": len(game_events),
+        "processing_time": time.time() - start_time,
+        "emotion_detection": "excited",  # محاكاة كشف المشاعر
+        "context_awareness": True
+    }
+    
+    logging.info(f"✅ تم توليد التعليق - {len(generated_commentary)} جملة")
+    return result
+
+@stream_offload
+def stream_quality_optimization(stream_metadata, target_bandwidth, viewer_count):
+    """تحسين جودة البث حسب النطاق الترددي وعدد المشاهدين"""
+    start_time = time.time()
+    
+    logging.info(f"📊 تحسين جودة البث - المشاهدين: {viewer_count}")
+    logging.info(f"🌐 النطاق المستهدف: {target_bandwidth} Mbps")
+    
+    # حساب الجودة المثلى
+    base_quality = min(target_bandwidth * 200, 1080)  # حد أقصى 1080p
+    
+    # تعديل حسب عدد المشاهدين
+    if viewer_count > 1000:
+        quality_adjustment = 0.8  # تقليل الجودة للأعداد الكبيرة
+    elif viewer_count > 100:
+        quality_adjustment = 0.9
+    else:
+        quality_adjustment = 1.0
+    
+    optimized_quality = int(base_quality * quality_adjustment)
+    
+    # تحديد FPS مناسب
+    if optimized_quality >= 1080:
+        optimal_fps = 60
+    elif optimized_quality >= 720:
+        optimal_fps = 45
+    else:
+        optimal_fps = 30
+    
+    time.sleep(0.5)  # محاكاة المعالجة
+    
+    result = {
+        "status": "success",
+        "original_quality": stream_metadata.get("quality", "1080p"),
+        "optimized_quality": f"{optimized_quality}p",
+        "optimal_fps": optimal_fps,
+        "target_bandwidth": target_bandwidth,
+        "viewer_count": viewer_count,
+        "bandwidth_saved": round(max(0, (1080 - optimized_quality) / 1080 * 100), 1),
+        "processing_time": time.time() - start_time,
+        "adaptive_streaming": True
+    }
+    
+    logging.info(f"✅ تم تحسين البث - الجودة: {result['optimized_quality']}")
+    return result
+
+# ═══════════════════════════════════════════════════════════════
+# إدارة البث المباشر
+# ═══════════════════════════════════════════════════════════════
+
+class LiveStreamCoordinator:
+    def __init__(self):
+        self.active_streams = {}
+        self.processing_history = []
+        
+    def start_stream(self, stream_id, config):
+        """بدء بث مباشر جديد"""
+        self.active_streams[stream_id] = {
+            "config": config,
+            "start_time": datetime.now(),
+            "status": "active",
+            "processing_nodes": [],
+            "viewers": 0
+        }
+        logging.info(f"🔴 بدء البث: {stream_id}")
+        
+    def distribute_processing(self, stream_id, task_type, data):
+        """توزيع معالجة البث على العقد المختلفة"""
+        if stream_id not in self.active_streams:
+            return {"error": "البث غير موجود"}
+            
+        # اختيار العقدة المناسبة
+        best_node = self._select_processing_node(task_type)
+        
+        # تنفيذ المعالجة
+        if best_node:
+            result = execute_remotely(task_type, [data], {})
+            self.active_streams[stream_id]["processing_nodes"].append(best_node)
+            return result
+        else:
+            # معالجة محلية
+            return self._process_locally(task_type, data)
+            
+    def _select_processing_node(self, task_type):
+        """اختيار أفضل عقدة للمعالجة"""
+        # منطق اختيار العقدة (مبسط)
+        return f"node_gpu_{np.random.randint(1, 4)}"
+        
+    def _process_locally(self, task_type, data):
+        """معالجة محلية احتياطية"""
+        return {"status": "processed_locally", "task": task_type}
+
+# دالة اختبار شاملة للبث المباشر
+def run_live_streaming_benchmark():
+    """اختبار شامل لنظام البث المباشر"""
+    print("\n📺🎮 اختبار نظام البث المباشر للألعاب والفيديو")
+    print("=" * 70)
+    
+    # بيانات تجريبية
+    game_stream_data = [f"frame_{i}" for i in range(60)]  # 60 إطار
+    game_events = ["goal", "save", "foul", "corner", "yellow_card"]
+    
+    multi_streams = [
+        {"quality": "1080p", "fps": 60, "complexity": 3},
+        {"quality": "720p", "fps": 30, "complexity": 2},
+        {"quality": "1440p", "fps": 45, "complexity": 4}
+    ]
+    
+    tests = [
+        ("معالجة بث لعبة", lambda: process_game_stream(game_stream_data, 60, "1920x1080", ["noise_reduction", "color_enhancement", "sharpening"])),
+        ("تحسين فيديو مباشر", lambda: real_time_video_enhancement(["upscaling", "noise_reduction", "hdr_enhancement"], "1080p", 60)),
+        ("معالجة متعددة البثوث", lambda: multi_stream_processing(multi_streams, "parallel")),
+        ("توليد تعليق ذكي", lambda: ai_commentary_generation(game_events, 50, "ar")),
+        ("تحسين جودة البث", lambda: stream_quality_optimization({"quality": "1080p"}, 5.0, 500))
+    ]
+    
+    coordinator = LiveStreamCoordinator()
+    
+    for test_name, test_func in tests:
+        print(f"\n🔄 تشغيل: {test_name}")
+        try:
+            result = test_func()
+            print(f"✅ نجح: {test_name}")
+            if "processing_time" in result:
+                print(f"⏱️ وقت المعالجة: {result['processing_time']:.2f}s")
+            if "quality_score" in result:
+                print(f"⭐ جودة: {result['quality_score']}%")
+        except Exception as e:
+            print(f"❌ فشل: {test_name} - {str(e)}")
+    
+    print("\n🏁 انتهى اختبار البث المباشر")
+
+if __name__ == "__main__":
+    run_live_streaming_benchmark()

load_balancer.py

@@ -0,0 +1,77 @@
+# load_balancer.py
+import peer_discovery, requests, time, smart_tasks, psutil, socket
+
+def send(peer, func, *args, **kw):
+    try:
+        r = requests.post(peer, json={"func": func,
+                                      "args": list(args),
+                                      "kwargs": kw}, timeout=12)
+        return r.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+def choose_peer():
+    """اختيار أفضل جهاز - أولوية LAN ثم WAN"""
+    import socket
+    
+    lan_peers = []
+    wan_peers = []
+    
+    # تصنيف الأجهزة
+    for p in list(peer_discovery.PEERS):
+        ip = p.split('//')[1].split(':')[0] if '//' in p else p.split(':')[0]
+        if is_local_ip(ip):
+            lan_peers.append(p)
+        else:
+            wan_peers.append(p)
+    
+    # أولاً: جرب الأجهزة المحلية (LAN)
+    best_lan = find_best_peer(lan_peers)
+    if best_lan:
+        return best_lan
+    
+    # ثانياً: إذا لم تتوفر أجهزة محلية، جرب WAN
+    if internet_available():
+        best_wan = find_best_peer(wan_peers)
+        return best_wan
+    
+    return None
+
+def find_best_peer(peers):
+    """العثور على أفضل جهاز من قائمة معينة"""
+    best = None
+    for p in peers:
+        try:
+            cpu = requests.get(p.replace("/run", "/cpu"), timeout=2).json()["usage"]
+            best = (p, cpu) if best is None or cpu < best[1] else best
+        except: 
+            continue
+    return best[0] if best else None
+
+def is_local_ip(ip):
+    """فحص إذا كان IP محلي"""
+    return (
+        ip.startswith('192.168.') or 
+        ip.startswith('10.') or 
+        ip.startswith('172.') or
+        ip == '127.0.0.1'
+    )
+
+def internet_available():
+    """فحص توفر الإنترنت"""
+    try:
+        socket.create_connection(("8.8.8.8", 53), timeout=3)
+        return True
+    except:
+        return False
+
+while True:
+    peer = choose_peer()
+    if peer:
+        print(f"\n🛰️  إرسال إلى {peer}")
+        res = send(peer, "prime_calculation", 30000)
+    else:
+        print("\n⚙️  لا أقران؛ العمل محليّ على", socket.gethostname())
+        res = smart_tasks.prime_calculation(30000)
+    print("🔹 النتيجة (جزئية):", str(res)[:120])
+    time.sleep(10)

main.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+"""
+main.py — نقطة تشغيل نظام OffloadHelper في ملف واحد
+خيارات سطر الأوامر:
+  -s / --stats-interval  ثواني بين كل طباعة لإحصائية الأقران (0 = مرة واحدة فقط)
+  --no-cli               تشغيل بلا قائمة تفاعلية حتى مع وجود TTY
+"""
+import os
+import sys
+import time
+import threading
+import subprocess
+import logging
+import argparse
+from pathlib import Path
+from typing import Any
+
+from flask import Flask, request, jsonify
+
+# ───────────────────── ضبط المسارات ──────────────────────
+FILE = Path(__file__).resolve()
+BASE_DIR = FILE.parent
+PROJECT_ROOT = BASE_DIR.parent
+for p in (BASE_DIR, PROJECT_ROOT):
+    sys.path.insert(0, str(p))
+
+# ───────────────────── إعداد السجلات ─────────────────────
+os.makedirs("logs", exist_ok=True)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("logs/main.log", mode="a")
+    ]
+)
+
+# ─────────────── تحميل متغيرات البيئة (اختياري) ───────────────
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+    logging.info("🔧 تم تحميل متغيرات البيئة من ‎.env")
+except ImportError:
+    logging.warning("🔧 python-dotenv غير مثبَّت؛ تَخطّي .env")
+
+# ─────────────── وحدات المشروع الداخلية ────────────────
+try:
+    from peer_discovery import (
+        register_service_lan,
+        discover_lan_loop,
+        register_with_central,
+        fetch_central_loop,
+        PEERS
+    )
+    from your_tasks import matrix_multiply, prime_calculation, data_processing
+    from distributed_executor import DistributedExecutor
+    from peer_statistics import print_peer_statistics
+except ImportError as e:
+    logging.error(f"❌ تعذّر استيراد وحدة: {e}")
+    sys.exit(1)
+
+# ─────────────── ثابتات التهيئة ───────────────
+CPU_PORT      = int(os.getenv("CPU_PORT", "7520"))
+SHARED_SECRET = os.getenv("SHARED_SECRET", "my_shared_secret_123")
+PYTHON_EXE    = sys.executable
+
+# ─────────────── خيارات سطر الأوامر ───────────────
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--stats-interval", "-s",
+    type=int,
+    default=0,
+    help="ثواني بين كل طباعة لإحصائية الأقران (0 = مرة واحدة فقط)"
+)
+parser.add_argument(
+    "--no-cli",
+    action="store_true",
+    help="تعطيل القائمة التفاعلية حتى عند وجود TTY"
+)
+args = parser.parse_args()
+
+# ─────────────── خادم Flask البسيط ───────────────
+flask_app = Flask(__name__)
+
+@flask_app.route("/run_task", methods=["POST"])
+def run_task_endpoint():
+    """اختبار: جمع عددين"""
+    data: dict[str, Any] | None = request.get_json(silent=True)
+    if not data:
+        return jsonify(error="No JSON received"), 400
+
+    if data.get("task") == "add":
+        a, b = data.get("a"), data.get("b")
+        if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+            return jsonify(result=a + b)
+    return jsonify(error="Invalid task or parameters"), 400
+
+def start_flask_server():
+    ip_public = os.getenv("PUBLIC_IP", "127.0.0.1")
+    logging.info(f"🌐 Flask متوفر على: http://{ip_public}:{CPU_PORT}/run_task")
+    flask_app.run(host="0.0.0.0", port=CPU_PORT, debug=False)
+
+# ─────────────── خدمات خلفية محلية ───────────────
+def start_services():
+    """peer_server و load_balancer"""
+    try:
+        subprocess.Popen([PYTHON_EXE, "peer_server.py", "--port", str(CPU_PORT)])
+        subprocess.Popen([PYTHON_EXE, "load_balancer.py"])
+        logging.info("✅ تم تشغيل الخدمات الخلفيّة")
+    except Exception as exc:
+        logging.error(f"❌ خطأ بتشغيل الخدمات الخلفية: {exc}")
+
+# ─────────────── مهام مثالية محلية ───────────────
+def example_task(x: int) -> int:
+    return x * x
+
+def benchmark(fn, *args):
+    t0 = time.time()
+    res = fn(*args)
+    return time.time() - t0, res
+
+# ─────────────── طباعة الإحصائية دوريًّا ─────────────
+def stats_loop(interval: int, executor: DistributedExecutor):
+    while True:
+        peers_now = [
+            {"ip": host, "port": port}
+            for (host, port) in executor.peer_registry.get_all()
+        ]
+        print_peer_statistics(peers_now)
+        time.sleep(interval)
+
+# ─────────────── القائمة التفاعلية CLI ─────────────
+def menu(executor: DistributedExecutor):
+    tasks = {
+        "1": ("ضرب المصفوفات", matrix_multiply, 500),
+        "2": ("حساب الأعداد الأولية", prime_calculation, 100_000),
+        "3": ("معالجة البيانات", data_processing, 10_000),
+        "5": ("مهمة موزعة (مثال)", example_task, 42),
+    }
+
+    while True:
+        print("\n🚀 نظام توزيع المهام الذكي")
+        for k, (title, _, _) in tasks.items():
+            print(f"{k}: {title}")
+        print("q: خروج")
+        choice = input("اختر المهمة: ").strip().lower()
+
+        if choice == "q":
+            print("🛑 تم إنهاء البرنامج.")
+            break
+        if choice not in tasks:
+            print("⚠️ اختيار غير صحيح.")
+            continue
+
+        name, fn, arg = tasks[choice]
+        print(f"\nتشغيل: {name}…")
+
+        try:
+            if choice == "5":
+                logging.info("📡 إرسال المهمة إلى العقد الموزَّعة…")
+                future = executor.submit(fn, arg)
+                print(f"✅ النتيجة (موزعة): {future.result()}")
+            else:
+                dur, res = benchmark(fn, arg)
+                print(f"✅ النتيجة: {res}\n⏱️ الوقت: {dur:.3f} ث")
+        except Exception as exc:
+            print(f"❌ خطأ في تنفيذ المهمة: {exc}")
+
+# ─────────────── الدالة الرئيسية ───────────────
+def main():
+    # 1) خدمات back‑end
+    start_services()
+
+    # 2) مهيّئ الموزِّع
+    executor = DistributedExecutor(SHARED_SECRET)
+    executor.peer_registry.register_service("node_main", CPU_PORT)
+
+    # 3) إضافة الأقران المكتشفين
+    for peer_url in list(PEERS):
+        try:
+            host, port_str = peer_url.split("//")[1].split("/run")[0].split(":")
+            executor.peer_registry.register_service(
+                f"peer_{host.replace('.', '_')}",
+                int(port_str)
+            )
+        except Exception as exc:
+            logging.warning(f"⚠️ تخطّي peer ({peer_url}): {exc}")
+
+    # 4) طباعة أولية
+    initial_peers = [
+        {"ip": host, "port": int(port)}
+        for peer_url in PEERS
+        if (hp := peer_url.split("//")[1].split("/run")[0]).count(":") == 1
+        for host, port in [hp.split(":")]
+    ]
+    print_peer_statistics(initial_peers)
+
+    # 5) حلقة إحصائية دورية
+    if args.stats_interval > 0:
+        threading.Thread(
+            target=stats_loop,
+            args=(args.stats_interval, executor),
+            daemon=True
+        ).start()
+
+    logging.info("✅ النظام جاهز للعمل")
+
+    # 6) CLI إن توفر TTY ولم يُطلَب no-cli
+    if not args.no_cli and sys.stdin.isatty():
+        menu(executor)
+    else:
+        logging.info("ℹ️ القائمة التفاعلية معطّلة (no TTY أو --no-cli)")
+
+# ─────────────── تشغيل البرنامج ───────────────
+if __name__ == "__main__":
+    # Zeroconf
+    threading.Thread(target=register_service_lan, daemon=True).start()
+    threading.Thread(target=discover_lan_loop, daemon=True).start()
+
+    # خادم وسيط مركزي
+    register_with_central()
+    threading.Thread(target=fetch_central_loop, daemon=True).start()
+
+    # ماسح إنترنت (اختياري)
+    try:
+        from internet_scanner import internet_scanner
+        threading.Thread(
+            target=internet_scanner.start_continuous_scan,
+            daemon=True
+        ).start()
+        logging.info("🔍 بدء المسح المستمر للإنترنت")
+    except ImportError:
+        logging.warning("🔍 internet_scanner غير متوافر – تم التخطي")
+
+    # Flask
+    threading.Thread(target=start_flask_server, daemon=True).start()
+
+    # وحدة تحكم (اختياري)
+    try:
+        from your_control import control
+        control.start()
+    except ImportError:
+        logging.info("🛈 your_control غير متوفّر – تشغيل افتراضي")
+
+    # CLI / إحصائية
+    main()
+

offload_lib.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+# offload_lib.py
+
+import time
+import math
+import random
+import psutil
+import requests
+import socket
+from functools import wraps
+from zeroconf import Zeroconf, ServiceBrowser
+import logging
+
+# إعداد السجل
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+# إعدادات التحميل
+MAX_CPU = 0.6  # عتبة استخدام CPU فقط
+
+class PeerListener:
+    def __init__(self):
+        self.peers = []
+
+    def add_service(self, zc, type, name):
+        info = zc.get_service_info(type, name)
+        if info:
+            ip = socket.inet_ntoa(info.addresses[0])
+            self.peers.append(f"{ip}:{info.port}")
+            logging.info(f"🔗 جهاز مكتشف: {ip}:{info.port}")
+
+    def update_service(self, zc, type, name):
+        logging.debug(f"🔄 تم تحديث الخدمة: {name}")
+        pass  # هنا فقط لتفادي التحذير
+
+def discover_peers(timeout=1.5):
+    """اكتشاف الأجهزة المتاحة - أولوية LAN ثم WAN ثم الإنترنت مع فحص المشروع"""
+    import peer_discovery
+    from project_identifier import verify_project_compatibility
+
+    zc = Zeroconf()
+    listener = PeerListener()
+    ServiceBrowser(zc, "_http._tcp.local.", listener)
+    time.sleep(timeout)
+    zc.close()
+
+    lan_peers = []
+    wan_peers = []
+    internet_peers = []
+
+    for peer in listener.peers:
+        ip = peer.split(':')[0]
+        if verify_peer_project(ip):
+            if is_local_network(ip):
+                lan_peers.append(peer)
+            else:
+                wan_peers.append(peer)
+
+    all_discovered = list(peer_discovery.PEERS)
+    for peer_url in all_discovered:
+        peer_ip = peer_url.split("://")[1].split(":")[0]
+        if verify_peer_project(peer_ip):
+            if is_local_network(peer_ip):
+                if peer_url not in lan_peers:
+                    lan_peers.append(peer_url)
+            else:
+                if peer_url not in wan_peers:
+                    internet_peers.append(peer_url)
+
+    all_peers = lan_peers + wan_peers + internet_peers
+    logging.info(f"اكتُشف {len(all_peers)} جهاز DTS متوافق - LAN: {len(lan_peers)}, WAN: {len(wan_peers)}, Internet: {len(internet_peers)}")
+
+    return all_peers
+
+def verify_peer_project(ip, port=7520):
+    """فحص إذا كان الجهاز يحتوي على نفس المشروع"""
+    try:
+        from project_identifier import verify_project_compatibility
+
+        project_url = f"http://{ip}:{port}/project_info"
+        response = requests.get(project_url, timeout=2)
+
+        if response.status_code == 200:
+            remote_info = response.json()
+            return verify_project_compatibility(remote_info)
+
+    except:
+        pass
+    return False
+
+def is_local_network(ip):
+    """فحص إذا كان IP في الشبكة المحلية"""
+    try:
+        import ipaddress
+        addr = ipaddress.ip_address(ip)
+        return (
+            addr.is_private or
+            str(addr).startswith('192.168.') or
+            str(addr).startswith('10.') or
+            str(addr).startswith('172.')
+        )
+    except:
+        return False
+
+def try_offload(peer, payload, max_retries=3):
+    """محاولة إرسال المهمة إلى جهاز آخر"""
+    url = f"http://{peer}/run"
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(url, json=payload, timeout=10)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logging.warning(f"فشل المحاولة {attempt + 1} لـ {peer}: {str(e)}")
+            time.sleep(0.5 * (attempt + 1))
+    raise ConnectionError(f"فشل جميع المحاولات لـ {peer}")
+
+def estimate_complexity(func, args, kwargs):
+    """تقدير تعقيد المهمة"""
+    if func.__name__ == "matrix_multiply":
+        return args[0] ** 2
+    elif func.__name__ == "prime_calculation":
+        return args[0] / 100
+    elif func.__name__ == "data_processing":
+        return args[0] / 10
+    elif func.__name__ == "image_processing_emulation":
+        return args[0] * 5
+    return 1  # قيمة افتراضية
+
+def offload(func):
+    """ديكوراتور لتوزيع المهام"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        cpu = psutil.cpu_percent(interval=0.5) / 100.0
+        mem = psutil.virtual_memory().available / (1024**2)
+        complexity = estimate_complexity(func, args, kwargs)
+
+        logging.info(f"حمل النظام - CPU: {cpu:.2f}, الذاكرة: {mem:.1f}MB, تعقيد المهمة: {complexity}")
+
+        if complexity > 50 or cpu > MAX_CPU:
+            try:
+                peers = discover_peers()
+                if peers:
+                    payload = {
+                        "func": func.__name__,
+                        "args": args,
+                        "kwargs": kwargs,
+                        "complexity": complexity
+                    }
+                    selected_peer = random.choice(peers)
+                    logging.info(f"إرسال المهمة إلى {selected_peer}")
+                    return try_offload(selected_peer, payload)
+            except Exception as e:
+                logging.error(f"خطأ في التوزيع: {str(e)}")
+
+        logging.info("تنفيذ المهمة محلياً")
+        return func(*args, **kwargs)
+    return wrapper
+
+# المهام القابلة للتوزيع:
+
+@offload
+def matrix_multiply(size):
+    """ضرب مصفوفتين عشوائيتين بالحجم"""
+    import numpy as np
+    A = np.random.rand(size, size)
+    B = np.random.rand(size, size)
+    return np.dot(A, B).tolist()
+
+@offload
+def prime_calculation(n):
+    """حساب الأعداد الأولية"""
+    primes = []
+    for num in range(2, n + 1):
+        is_prime = True
+        for i in range(2, int(math.sqrt(num)) + 1):
+            if num % i == 0:
+                is_prime = False
+                break
+        if is_prime:
+            primes.append(num)
+    return {"primes_count": len(primes), "primes": primes}
+
+@offload
+def data_processing(data_size):
+    """معالجة بيانات كبيرة"""
+    processed_data = []
+    for i in range(data_size):
+        result = sum(math.sin(x) * math.cos(x) for x in range(i, i + 100))
+        processed_data.append(result)
+    return {"processed_items": len(processed_data)}
+
+@offload
+def image_processing_emulation(iterations):
+    """محاكاة معالجة الصور"""
+    results = []
+    for i in range(iterations):
+        fake_processing = sum(math.sqrt(x) for x in range(i * 100, (i + 1) * 100))
+        results.append(fake_processing)
+        time.sleep(0.01)
+    return {"iterations": iterations, "results": results}

peer_discovery.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+import os
+import socket
+import threading
+import time
+import logging
+
+import requests
+from zeroconf import Zeroconf, ServiceInfo, ServiceBrowser
+
+# 👇 إعداد الـ peer discovery عبر LAN وInternet
+SERVICE = "_tasknode._tcp.local."
+PORT = int(os.getenv("CPU_PORT", "7520"))
+PEERS = set()  # مجموعة URLs للأقران (/run)
+
+# 🌐 خادم وسيط مركزي (Central Registry)
+CENTRAL_REGISTRY_URL = "https://cv4790811.regru.cloud"
+
+# 🟢 دالة لحساب IP العام أو المحلي
+# تستخدم HTTP API للحصول على IP عام ثم fallback إلى LAN
+
+def get_local_ip():
+    # حاول الحصول على IP عام
+    try:
+        r = requests.get("https://api.ipify.org?format=json", timeout=3)
+        r.raise_for_status()
+        data = r.json()
+        return data.get("ip", "127.0.0.1")
+    except Exception:
+        # fallback إلى LAN IP
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            s.connect(("8.8.8.8", 80))
+            return s.getsockname()[0]
+        except Exception:
+            return "127.0.0.1"
+        finally:
+            try:
+                s.close()
+            except Exception:
+                pass
+
+# ❶ تسجيل الخدمة في شبكة LAN عبر Zeroconf
+# للحفاظ على قدرة اكتشاف peers في نفس الشبكة المحلية
+def register_service_lan():
+    zc = Zeroconf()
+    local_ip = get_local_ip()
+    info = ServiceInfo(
+        SERVICE,
+        f"{socket.gethostname()}.{SERVICE}",
+        addresses=[socket.inet_aton(local_ip)],
+        port=PORT,
+        properties={b'load': b'0'}
+    )
+    try:
+        zc.register_service(info)
+        print(f"✅ LAN service registered: {local_ip}:{PORT}")
+    except Exception as e:
+        print(f"❌ LAN registration failed: {e}")
+
+# ❷ مستمع لاكتشاف أجهزة LAN عبر Zeroconf
+class Listener:
+    def add_service(self, zc, t, name):
+        info = zc.get_service_info(t, name)
+        if info and info.addresses:
+            ip = socket.inet_ntoa(info.addresses[0])
+            peer_url = f"http://{ip}:{info.port}/run"
+            if peer_url not in PEERS:
+                PEERS.add(peer_url)
+                print(f"🔗 LAN peer discovered: {peer_url}")
+    def update_service(self, zc, t, name):
+        self.add_service(zc, t, name)
+    def remove_service(self, zc, t, name):
+        print(f"❌ LAN peer removed: {name}")
+
+# حلقة اكتشاف LAN مستمرة
+def discover_lan_loop():
+    zc = Zeroconf()
+    ServiceBrowser(zc, SERVICE, Listener())
+    print(f"🔍 Started LAN discovery for {SERVICE}")
+    while True:
+        time.sleep(5)
+
+# ❸ تسجيل العقدة في الخادم المركزي
+# ترسل بياناتها إلى /register وتضيف باقي الأقران
+def register_with_central():
+    node_id = os.getenv("NODE_ID", socket.gethostname())
+    info = {"node_id": node_id, "ip": get_local_ip(), "port": PORT}
+    try:
+        resp = requests.post(f"{CENTRAL_REGISTRY_URL}/register", json=info, timeout=5)
+        resp.raise_for_status()
+        peers_list = resp.json()
+        for p in peers_list:
+            peer_url = f"http://{p['ip']}:{p['port']}/run"
+            if peer_url not in PEERS:
+                PEERS.add(peer_url)
+                print(f"🌐 Registered and discovered central peer: {peer_url}")
+    except Exception as e:
+        print(f"❌ Central registration failed: {e}")
+
+# ❹ مزامنة الأقران من الخادم المركزي بشكل دوري
+# تُحدّث مجموعة PEERS كل 5 دقائق عن طريق /peers endpoint
+def fetch_central_loop():
+    print("🔄 Central registry sync loop started")
+    while True:
+        try:
+            resp = requests.get(f"{CENTRAL_REGISTRY_URL}/peers", timeout=5)
+            resp.raise_for_status()
+            peers_list = resp.json()
+            for p in peers_list:
+                peer_url = f"http://{p['ip']}:{p['port']}/run"
+                if peer_url not in PEERS:
+                    PEERS.add(peer_url)
+                    print(f"🌐 Central peer discovered: {peer_url}")
+        except Exception as e:
+            print(f"⚠️ Fetch central peers failed: {e}")
+        time.sleep(300)
+
+# 🚀 دالة الإدخال الرئيسيّة
+def main():
+    logging.basicConfig(level=logging.INFO)
+    print("🚀 Peer Discovery System starting...")
+
+    # Zeroconf LAN registration & discovery
+    threading.Thread(target=register_service_lan, daemon=True).start()
+    threading.Thread(target=discover_lan_loop, daemon=True).start()
+
+    # التسجيل في الخادم الوسيط ومزامنة الأقران
+    register_with_central()
+    threading.Thread(target=fetch_central_loop, daemon=True).start()
+
+    # إبقاء السكربت قيد التشغيل
+    try:
+        while True:
+            time.sleep(60)
+    except KeyboardInterrupt:
+        print("🛑 Exiting...")
+
+if __name__ == "__main__":
+    main()

peer_registry.py

@@ -0,0 +1,67 @@
+import socket
+import time
+from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
+
+class Listener:
+    def __init__(self):
+        self.peers = []
+
+    def add_service(self, zc, type_, name):
+        info = zc.get_service_info(type_, name)
+        if info:
+            ip = socket.inet_ntoa(info.addresses[0])
+            peer_data = {
+                'ip': ip,
+                'port': info.port,
+                'load': float(info.properties.get(b'load', 0)),
+                'node_id': info.properties.get(b'node_id', b'unknown').decode(),
+                'last_seen': time.time()
+            }
+            if peer_data not in self.peers:
+                self.peers.append(peer_data)
+
+    def update_service(self, zc, type_, name):
+        """مطلوب بواسطة Zeroconf"""
+        self.add_service(zc, type_, name)
+
+    def remove_service(self, zc, type_, name):
+        """اختياري"""
+        pass
+
+def register_service(ip: str, port: int, load: float = 0.0):
+    zc = Zeroconf()
+    service_name = f"{socket.gethostname()}-{int(time.time())}._tasknode._tcp.local."
+    service_info = ServiceInfo(
+        "_tasknode._tcp.local.",
+        service_name,
+        addresses=[socket.inet_aton(ip)],
+        port=port,
+        properties={
+            b'load': str(load).encode(),
+            b'node_id': socket.gethostname().encode()
+        }
+    )
+    zc.register_service(service_info)
+    print(f"✅ Service registered: {service_name} @ {ip}:{port}")
+    return zc  # أبقِ المرجع حياً
+
+def discover_peers(timeout=2):
+    zc = Zeroconf()
+    listener = Listener()
+    ServiceBrowser(zc, "_tasknode._tcp.local.", listener)
+    time.sleep(timeout)
+    zc.close()
+    return listener.peers
+
+if __name__ == "__main__":
+    local_ip = socket.gethostbyname(socket.gethostname())
+    port = 7520
+
+    zc = register_service(local_ip, port, load=0.1)
+
+    peers = discover_peers()
+    print("✅ Available peers:", peers)
+
+    input("🔵 Press Enter to exit...\n")
+    zc.close()
+

peer_server.py

@@ -0,0 +1,37 @@
+# peer_server.py
+
+from flask import Flask, request, jsonify  # استيراد request و jsonify مع Flask
+import psutil
+import smart_tasks
+import time
+import socket
+import peer_discovery  # إذا كان يستخدم لاحقًا
+
+app = Flask(__name__)  # إنشاء التطبيق
+
+@app.route("/cpu")
+def cpu():
+    # يعيد نسبة استخدام المعالج
+    return jsonify(usage=psutil.cpu_percent(interval=0.3))
+
+@app.route("/run", methods=["POST"])
+def run():
+    data = request.get_json(force=True)
+    fn_name = data.get("func")
+    fn = getattr(smart_tasks, fn_name, None)
+    if not fn:
+        return jsonify(error="function-not-found"), 404
+    try:
+        start = time.time()
+        result = fn(*data.get("args", []), **data.get("kwargs", {}))
+        return jsonify(
+            result=result,
+            host=socket.gethostname(),
+            took=round(time.time() - start, 3)
+        )
+    except Exception as e:
+        return jsonify(error=str(e)), 500
+
+if __name__ == "__main__":  # التصحيح هنا
+    app.run(host="0.0.0.0", port=7520)
+

peer_statistics.py

@@ -0,0 +1,21 @@
+from collections import Counter
+import ipaddress
+
+def print_peer_statistics(discovered_peers):
+    ips = [peer['ip'] for peer in discovered_peers]
+    ip_counts = Counter(ips)
+
+    def classify_ip(ip):
+        try:
+            ip_obj = ipaddress.ip_address(ip)
+            if ip_obj.is_private:
+                return 'داخلي'
+            else:
+                return 'خارجي'
+        except ValueError:
+            return 'محلي'
+
+    print("\n📊 إحصائية عدد الأجهزة حسب النوع:\n")
+    for ip, count in ip_counts.items():
+        category = classify_ip(ip)
+        print(f"• {ip} ({category}): {count} جهاز")

processor_manager.py

@@ -0,0 +1,73 @@
+# processor_manager.py
+
+import psutil
+from collections import deque
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+class ResourceMonitor:
+    def __init__(self):
+        self.cpu_history = deque(maxlen=10)
+        self.mem_history = deque(maxlen=10)
+        # حد استقبال المهمات الآن 40% CPU بدل 30%
+        self.receive_cpu_threshold = 0.40  
+
+    def current_load(self):
+        cpu = psutil.cpu_percent(interval=0.5) / 100.0    # كنسبة (0.0 - 1.0)
+        mem = psutil.virtual_memory().available / (1024**2)  # متاح بالـ MB
+
+        self.cpu_history.append(cpu)
+        self.mem_history.append(mem)
+
+        avg_cpu = sum(self.cpu_history) / len(self.cpu_history)
+        avg_mem = sum(self.mem_history) / len(self.mem_history)
+
+        logging.info(f"Instant CPU: {cpu:.2%}, Instant MEM: {mem:.1f}MB")
+        logging.info(f"Avg CPU: {avg_cpu:.2%}, Avg MEM: {avg_mem:.1f}MB")
+
+        recommendation = "offload" if (avg_cpu > 0.7 or avg_mem < 2048) else "local"
+        can_receive = avg_cpu <= self.receive_cpu_threshold
+
+        return {
+            "instant": {"cpu": cpu, "mem": mem},
+            "average": {"cpu": avg_cpu, "mem": avg_mem},
+            "recommendation": recommendation,
+            "can_receive": can_receive
+        }
+
+def trigger_offload():
+    """عملية توزيع المهام التجريبية"""
+    print("⚠️ تم استدعاء توزيع المهام (اختباري)")
+
+def should_offload(task_complexity=0):
+    monitor = ResourceMonitor()
+    status = monitor.current_load()
+
+    avg_cpu = status['average']['cpu']
+    avg_mem = status['average']['mem']
+
+    if avg_cpu > 0.6 or avg_mem < 2048 or task_complexity > 75:
+        trigger_offload()
+        return True
+
+    return False
+
+def can_receive_task():
+    """
+    يعيد True إذا كان بالإمكان استقبال مهمة جديدة،
+    أي عندما يكون متوسط استهلاك الـ CPU ≤ 40%.
+    """
+    return ResourceMonitor().current_load()["can_receive"]
+
+if __name__ == "__main__":
+    status = ResourceMonitor().current_load()
+    if not status["can_receive"]:
+        print(f"🚫 لا يمكن استقبال مهام جديدة (Avg CPU: {status['average']['cpu']:.0%})")
+    else:
+        print(f"✅ يمكن استقبال مهام جديدة (Avg CPU: {status['average']['cpu']:.0%})")
+
+    if should_offload(80):
+        print("💡 ينصح بتوزيع المهمة")
+    else:
+        print("✅ يمكن تنفيذ المهمة محلياً")

project_identifier.py

@@ -0,0 +1,41 @@
+
+"""
+project_identifier.py - معرف المشروع للتحقق من الهوية
+"""
+import json
+from flask import jsonify
+
+PROJECT_INFO = {
+    "project_name": "distributed-task-system",
+    "version": "1.0",
+    "description": "نظام توزيع المهام الذكي",
+    "author": "DTS Team",
+    "features": [
+        "matrix_multiply",
+        "prime_calculation", 
+        "data_processing",
+        "video_processing",
+        "live_streaming",
+        "enhanced_ai"
+    ],
+    "signature": "DTS_2024_SMART_DISTRIBUTION"
+}
+
+def get_project_info():
+    """إرجاع معلومات المشروع"""
+    return PROJECT_INFO
+
+def verify_project_compatibility(remote_info):
+    """التحقق من توافق المشروع مع جهاز آخر"""
+    if not isinstance(remote_info, dict):
+        return False
+        
+    return (
+        remote_info.get("project_name") == PROJECT_INFO["project_name"] and
+        remote_info.get("version") == PROJECT_INFO["version"] and
+        remote_info.get("signature") == PROJECT_INFO["signature"]
+    )
+
+def create_project_endpoint():
+    """إنشاء endpoint لمعلومات المشروع"""
+    return jsonify(PROJECT_INFO)

quick_connection_test.py

@@ -0,0 +1,49 @@
+
+#!/usr/bin/env python3
+# اختبار سريع للتحقق من حالة النظام
+
+import requests
+import time
+import json
+from offload_lib import discover_peers, matrix_multiply
+
+def test_connection():
+    """اختبار سريع للاتصال"""
+    print("🚀 اختبار اتصال سريع...")
+    
+    # 1. فحص الخادم المحلي
+    try:
+        response = requests.get("http://localhost:7520/health", timeout=3)
+        if response.status_code == 200:
+            print("✅ الخادم المحلي يعمل")
+        else:
+            print("❌ مشكلة في الخادم المحلي")
+            return False
+    except:
+        print("❌ الخادم المحلي غير متاح")
+        return False
+    
+    # 2. اختبار اكتشاف الأجهزة
+    print("🔍 البحث عن الأجهزة...")
+    peers = discover_peers(timeout=2)
+    print(f"📱 تم اكتشاف {len(peers)} جهاز")
+    
+    # 3. اختبار مهمة بسيطة
+    print("⚙️ اختبار مهمة بسيطة...")
+    start_time = time.time()
+    try:
+        result = matrix_multiply(5)
+        duration = time.time() - start_time
+        print(f"✅ تمت المعالجة في {duration:.2f} ثانية")
+        print(f"📊 النتيجة: مصفوفة {len(result)}x{len(result[0])}")
+        return True
+    except Exception as e:
+        print(f"❌ فشل في المعالجة: {e}")
+        return False
+
+if __name__ == "__main__":
+    if test_connection():
+        print("\n🎉 النظام يعمل بشكل جيد!")
+        print("💡 يمكنك الآن تشغيل: python test_distributed_system.py")
+    else:
+        print("\n⚠️ هناك مشاكل تحتاج إصلاح")

quick_test.py

@@ -0,0 +1,80 @@
+
+#!/usr/bin/env python3
+# quick_test.py - اختبار سريع لنظام التوزيع
+
+import requests
+import time
+from offload_lib import discover_peers
+
+def quick_connectivity_test():
+    """اختبار سريع للاتصال والتوزيع"""
+    print("🚀 اختبار سريع لنظام التوزيع")
+    print("-" * 40)
+    
+    # 1. اكتشاف الأجهزة
+    print("🔍 البحث عن الأجهزة...")
+    peers = discover_peers(timeout=2)
+    
+    if not peers:
+        print("❌ لم يتم العثور على أجهزة أخرى")
+        return False
+    
+    print(f"✅ تم العثور على {len(peers)} جهاز:")
+    for peer in peers:
+        print(f"   📱 {peer}")
+    
+    # 2. اختبار الاتصال السريع
+    working_peers = []
+    for peer in peers:
+        try:
+            response = requests.get(f"{peer}/health", timeout=3)
+            if response.status_code == 200:
+                working_peers.append(peer)
+                print(f"✅ {peer} - متصل ويعمل")
+            else:
+                print(f"⚠️ {peer} - يستجيب لكن بخطأ")
+        except:
+            print(f"❌ {peer} - غير متصل")
+    
+    if not working_peers:
+        print("❌ لا توجد أجهزة تعمل بشكل صحيح")
+        return False
+    
+    # 3. اختبار إرسال مهمة بسيطة
+    print(f"\n📡 اختبار إرسال مهمة إلى {working_peers[0]}...")
+    
+    task = {
+        "func": "matrix_multiply",
+        "args": [5],
+        "kwargs": {}
+    }
+    
+    try:
+        start_time = time.time()
+        response = requests.post(f"{working_peers[0]}/run", json=task, timeout=10)
+        duration = time.time() - start_time
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"✅ تمت المعالجة بنجاح في {duration:.2f} ثانية")
+            print(f"📊 النتيجة: تم ضرب مصفوفة 5x5")
+            return True
+        else:
+            print(f"❌ فشل في المعالجة - كود الخطأ: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في الإرسال: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    success = quick_connectivity_test()
+    
+    if success:
+        print("\n🎉 النظام يعمل بشكل صحيح!")
+        print("💡 يمكنك الآن تشغيل الاختبار الشامل: python test_distributed_system.py")
+    else:
+        print("\n⚠️ هناك مشاكل في النظام، تحقق من:")
+        print("   1. تشغيل الخادم على الأجهزة الأخرى")
+        print("   2. الاتصال بالشبكة")
+        print("   3. إعدادات الجدار الناري")

remote_executor.py

@@ -0,0 +1,104 @@
+# remote_executor.py (مُحدَّث: يدعم التشفير والتوقيع واختيار السيرفر ديناميكياً)
+# ============================================================
+# يرسل المهمّة إلى سيرفر RPC خارجي مع تشفير + توقيع،
+# أو يعمل بوضع JSON صافٍ لو لم يكن SecurityManager مفعَّل.
+# يستخدم قائمة الأقران المكتشفة لاختيار الـ endpoint بدل IP ثابت.
+# ============================================================
+
+import requests
+import json
+import os
+from typing import Any
+
+# قائمة الأقران (URLs) المستخرجة من peer_discovery
+from peer_discovery import PEERS
+
+# عنوان افتراضي احتياطي (يمكن تغييره بمتغير بيئي REMOTE_SERVER)
+FALLBACK_SERVER = os.getenv(
+    "REMOTE_SERVER",
+    "http://89.111.171.92:7520/run"
+)
+
+# محاولة استيراد SecurityManager (اختياري)
+try:
+    from security_layer import SecurityManager
+    security = SecurityManager(os.getenv("SHARED_SECRET", "my_shared_secret_123"))
+    SECURITY_ENABLED = True
+except ImportError:
+    security = None
+    SECURITY_ENABLED = False
+
+
+def _choose_remote_server() -> str:
+    """
+    يختار عنوان السيرفر الذي سترسل إليه المهمة:
+    1) إذا عُيّن متغير بيئي REMOTE_SERVER، يُستخدم.
+    2) وإلا إذا اكتشفنا أقران عبر LAN/Internet، نأخذ أولهم.
+    3) وإلا نعود إلى FALLBACK_SERVER.
+    """
+    env_url = os.getenv("REMOTE_SERVER")
+    if env_url:
+        return env_url.rstrip('/') + '/run'
+    # PEERS يحوي عناوين كاملة من نوع http://ip:port/run
+    if PEERS:
+        # نختار الحد الأدنى من التحميل (اختياري) أو أول عنصر
+        # هنا ببساطة نأخذ أول URL
+        return next(iter(PEERS))
+    # استخدام الافتراضي
+    return FALLBACK_SERVER.rstrip('/') + '/run'
+
+
+def execute_remotely(
+    func_name: str,
+    args: list[Any] | None = None,
+    kwargs: dict[str, Any] | None = None
+) -> Any:
+    """إرسال استدعاء دالة إلى الخادم البعيد وإرجاع النتيجة."""
+    if args is None:
+        args = []
+    if kwargs is None:
+        kwargs = {}
+
+    task = {
+        "func": func_name,
+        "args": args,
+        "kwargs": kwargs,
+        "sender_id": "client_node"
+    }
+
+    # اختيار السيرفر الصحيح ديناميكياً
+    target_url = _choose_remote_server()
+
+    try:
+        if SECURITY_ENABLED:
+            # 1) وقّع المهمة ثم شفّرها
+            signed_task = security.sign_task(task)
+            encrypted   = security.encrypt_data(json.dumps(signed_task).encode())
+
+            headers = {
+                "X-Signature": security.signature_hex,
+                "Content-Type": "application/octet-stream"
+            }
+            payload = encrypted  # خام ثنائي
+            resp = requests.post(
+                target_url,
+                headers=headers,
+                data=payload,
+                timeout=15
+            )
+        else:
+            # وضع التطوير: أرسل JSON صريح
+            headers = {"Content-Type": "application/json"}
+            resp = requests.post(
+                target_url,
+                headers=headers,
+                json=task,
+                timeout=15
+            )
+
+        resp.raise_for_status()
+        data = resp.json()
+        return data.get("result", "⚠️ لا يوجد نتيجة")
+
+    except Exception as e:
+        return f"❌ فشل التنفيذ البعيد على {target_url}: {e}"

rpc_server.py

@@ -0,0 +1,73 @@
+# rpc_server.py (مُحدَّث بحيث يدعم التشفير الاختياري)
+# ============================================================
+# خادِم يستقبل مهام عن بُعد:
+#   • إن وصلته بيانات خام (Encrypted) في Body → يفك تشفيرها ويتحقق من التوقيع.
+#   • وإلا إن وصل JSON خام في Content‑Type: application/json → ينفّذ مباشرة (وضع تطويـر).
+# ============================================================
+
+from flask import Flask, request, jsonify
+import smart_tasks  # «your_tasks» تمّ استيراده تحت هذا الاسم فى main.py
+import logging, json
+from security_layer import SecurityManager
+
+SECURITY = SecurityManager("my_shared_secret_123")
+
+logging.basicConfig(
+    filename="server.log",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+app = Flask(name)
+
+# ------------------------------------------------------------------
+@app.route("/health")
+def health():
+    return jsonify(status="ok")
+
+# ------------------------------------------------------------------
+@app.route("/run", methods=["POST"])
+def run():
+    try:
+        # 1) حاول قراءة كـ JSON مباشر (وضع التطويـر)
+        if request.is_json:
+            data = request.get_json()
+        else:
+            # 2) وإلا اعتبره Payload مُشفَّر (وضع الإنتاج)
+            encrypted = request.get_data()
+            try:
+                decrypted = SECURITY.decrypt_data(encrypted)
+                data = json.loads(decrypted.decode())
+            except Exception as e:
+                logging.error(f"⚠️ فشل فك التشفير: {e}")
+                return jsonify(error="Decryption failed"), 400
+
+        # 3) التحقّق من التوقيع إن وُجد
+        if "_signature" in data:
+            if not SECURITY.verify_task(data):
+                logging.warning("❌ توقيع غير صالح")
+                return jsonify(error="Invalid signature"), 403
+            # أزل عناصر موقّعة إضافية
+            data = {k: v for k, v in data.items() if k not in ("_signature", "sender_id")}
+
+        func_name = data.get("func")
+        args      = data.get("args", [])
+        kwargs    = data.get("kwargs", {})
+
+        fn = getattr(smart_tasks, func_name, None)
+        if not fn:
+            logging.warning(f"❌ لم يتم العثور على الدالة: {func_name}")
+            return jsonify(error="Function not found"), 404
+
+        logging.info(f"⚙️ تنفيذ الدالة: {func_name} من جهاز آخر")
+        result = fn(*args, **kwargs)
+        return jsonify(result=result)
+
+    except Exception as e:
+        logging.error(f"🔥 خطأ أثناء تنفيذ المهمة: {str(e)}")
+        return jsonify(error=str(e)), 500
+
+# ------------------------------------------------------------------
+if name == "main":
+    # تأكد أن المنفذ 7520 مفتوح
+    app.run(host="0.0.0.0", port=7520)

security_layer.py

@@ -0,0 +1,120 @@
+# security_layer.py (مُحدَّث)
+# ============================================================
+# إدارة التشفير والتوقيع وتبادل المفاتيح بين العقد
+# ============================================================
+
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import rsa, padding
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.fernet import Fernet
+import os, base64, json
+from typing import Dict
+
+
+class SecurityManager:
+    """طبقة أمان موحّدة لكل العقد."""
+
+    def __init__(self, shared_secret: str):
+        # مفتاح متماثل لاستخدام Fernet
+        self._key = self._derive_key(shared_secret)
+        self._cipher = Fernet(self._key)
+
+        # زوج مفاتيح غير متماثل للتوقيع الرقمي
+        self._private_key = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=2048,
+        )
+        self._public_pem = (
+            self._private_key.public_key()
+            .public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo,
+            )
+            .decode()
+        )
+        # مفاتيح العقد الأخرى {peer_id: public_key_obj}
+        self._peer_keys: Dict[str, rsa.RSAPublicKey] = {}
+
+    # ------------------------------------------------------------
+    # تشفير / فك تشفير متماثل
+    # ------------------------------------------------------------
+    def encrypt_data(self, data: bytes) -> bytes:
+        return self._cipher.encrypt(data)
+
+    def decrypt_data(self, encrypted: bytes) -> bytes:
+        return self._cipher.decrypt(encrypted)
+
+    # ------------------------------------------------------------
+    # توقيع/تحقّق رقمي غير متماثل
+    # ------------------------------------------------------------
+    def sign_task(self, task: Dict) -> Dict:
+        """يُرجع نسخة موقّعة من الـtask مضافًا إليها المفتاح العام والمعرّف."""
+        signature = self._private_key.sign(
+            json.dumps(task, separators=(",", ":")).encode(),
+            padding.PSS(
+                mgf=padding.MGF1(hashes.SHA256()),
+                salt_length=padding.PSS.MAX_LENGTH,
+            ),
+            hashes.SHA256(),
+        )
+        task_signed = task.copy()
+        task_signed.update(
+            {
+                "_signature": base64.b64encode(signature).decode(),
+                "sender_id": os.getenv("NODE_ID", "unknown"),
+                "sender_key": self._public_pem,
+            }
+        )
+        return task_signed
+
+    def verify_task(self, signed_task: Dict) -> bool:
+        """يتحقق من صحة التوقيع باستخدام المفتاح العام للمرسل."""
+        if "_signature" not in signed_task or "sender_id" not in signed_task:
+            return False
+        sig = base64.b64decode(signed_task["_signature"])
+        task_copy = {k: v for k, v in signed_task.items() if k not in {"_signature", "sender_key"}}
+
+        peer_id = signed_task["sender_id"]
+        if peer_id not in self._peer_keys:
+            # حاول إضافة المفتاح المرسل إن وجد
+            if "sender_key" in signed_task:
+                self.add_peer_key(peer_id, signed_task["sender_key"])
+            else:
+                return False
+        try:
+            self._peer_keys[peer_id].verify(
+                sig,
+                json.dumps(task_copy, separators=(",", ":")).encode(),
+                padding.PSS(
+                    mgf=padding.MGF1(hashes.SHA256()),
+                    salt_length=padding.PSS.MAX_LENGTH,
+                ),
+                hashes.SHA256(),
+            )
+            return True
+        except Exception:
+            return False
+
+    # ------------------------------------------------------------
+    # إدارة المفاتيح العامة للأقران
+    # ------------------------------------------------------------
+    def add_peer_key(self, peer_id: str, public_key_pem: str):
+        """تخزين/تحديث المفتاح العام لعقدة أخرى."""
+        self._peer_keys[peer_id] = serialization.load_pem_public_key(
+            public_key_pem.encode()
+        )
+
+    # ------------------------------------------------------------
+    # أدوات داخلية
+    # ------------------------------------------------------------
+    @staticmethod
+    def _derive_key(password: str) -> bytes:
+        salt = b"nora_salt_2025"  # ◀️ عدِّل في الإنتاج
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=salt,
+            iterations=150_000,
+        )
+        return base64.urlsafe_b64encode(kdf.derive(password.encode()))
+

server.py

@@ -0,0 +1,32 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import json
+from your_tasks import *
+from project_identifier import create_project_endpoint, get_project_info
+import logging
+
+app = Flask(__name__)
+CORS(app)
+
+@app.route('/multiply', methods=['POST'])
+def multiply():
+    try:
+        data = request.get_json()
+        a = data.get("a", 0)
+        b = data.get("b", 0)
+        result_dict = multiply_task(a, b)  # دالة offload
+        return jsonify({"result": result_dict["result"]})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    return jsonify({"status": "healthy", "port": 7520})
+
+@app.route('/project_info', methods=['GET'])
+def project_info():
+    return create_project_endpoint()
+
+if __name__ == "__main__":
+    # هذا العنوان يسمح بالاستماع على IP خارجي لتلقي الاتصالات من الإنترنت
+    app.run(host="0.0.0.0", port=7520)

setup.py

@@ -0,0 +1,69 @@
+# setup.py
+import configparser
+# Monkey-patch for Python 3: define SafeConfigParser for stdeb compatibility
+configparser.SafeConfigParser = configparser.RawConfigParser
+
+from setuptools import setup, find_packages
+
+# Load long description from README
+with open("README.md", encoding="utf-8") as f:
+    long_desc = f.read()
+
+setup(
+    name="distributed-task-system",
+    version="1.0",
+    description="A simple distributed task offload system",
+    long_description=long_desc,
+    long_description_content_type="text/markdown",
+    author="Osama Awartany",
+    author_email="osama@example.com",
+    url="https://github.com/yourusername/distributed-task-system",
+    packages=find_packages(include=["offload_core", "offload_core.*"]),
+    py_modules=["dts_cli"],  # Include the CLI helper module
+    install_requires=[
+        "flask",
+        "requests",
+        "psutil",
+        "zeroconf",
+        "flask_cors",
+        "numpy",
+        "uvicorn"
+    ],
+    entry_points={
+        "console_scripts": [
+            "dts-start=dts_cli:main",
+        ],
+    },
+    data_files=[
+        ("/etc/systemd/system", ["dts.service"])
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: POSIX :: Linux",
+    ],
+    python_requires='>=3.6',
+)
+
+
+# dts_cli.py
+# CLI entry-point module for the Distributed Task System
+# Place this next to setup.py
+
+def main():
+    """
+    Main entry for dts-start console script.
+    Launches the FastAPI/Flask app via Uvicorn.
+    """
+    # Import your application instance here:
+    try:
+        from offload_core.main import app
+    except ImportError:
+        # If you have a factory, adjust accordingly:
+        from offload_core.main import create_app
+        app = create_app()
+
+    # Run with Uvicorn
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7520)
+

setup_fonts.py

@@ -0,0 +1,20 @@
+import os
+import requests
+
+FONT_DIR = "fonts"
+FONT_PATH = os.path.join(FONT_DIR, "Cairo-Regular.ttf")
+
+# 🔥 رابط مباشر من Google Fonts CDN - Cairo Regular وزن 400
+URL = "https://fonts.cdnfonts.com/s/12667/Cairo-Regular.woff"
+
+os.makedirs(FONT_DIR, exist_ok=True)
+
+print("[+] تحميل الخط Cairo-Regular...")
+response = requests.get(URL)
+if response.status_code == 200:
+    with open(FONT_PATH, "wb") as f:
+        f.write(response.content)
+    print(f"[✅] تم حفظ الخط في {FONT_PATH}")
+else:
+    print(f"[❌] فشل تحميل الخط! كود الحالة: {response.status_code}")
+

simple_assistant.py

@@ -0,0 +1,101 @@
+
+# -*- coding: utf-8 -*-
+
+import os
+import json
+import random
+import re
+from datetime import datetime
+
+class SimpleNoraAssistant:
+    def __init__(self):
+        self.history_path = "simple_history.json"
+        self.chat_history = self.load_history()
+        self.knowledge_base = {
+            "تحية": ["مرحباً!", "أهلاً وسهلاً!", "كيف حالك؟"],
+            "وقت": [f"الوقت الحالي: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"],
+            "مساعدة": ["يمكنني مساعدتك في الأسئلة البسيطة والدردشة!", "اسألني أي سؤال وسأحاول المساعدة!"],
+            "برمجة": ["البرمجة مهارة رائعة!", "ما نوع البرمجة التي تريد تعلمها؟"],
+            "افتراضي": ["مثير للاهتمام!", "حدثني أكثر عن ذلك.", "هذا سؤال جيد!"]
+        }
+    
+    def load_history(self):
+        """تحميل سجل المحادثة"""
+        if os.path.exists(self.history_path):
+            try:
+                with open(self.history_path, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except:
+                return []
+        return []
+    
+    def save_history(self):
+        """حفظ سجل المحادثة"""
+        with open(self.history_path, "w", encoding="utf-8") as f:
+            json.dump(self.chat_history, f, ensure_ascii=False, indent=2)
+    
+    def get_response(self, user_input: str) -> str:
+        """الحصول على رد بسيط"""
+        user_input = user_input.lower().strip()
+        
+        # تحديد نوع السؤال
+        if any(word in user_input for word in ["مرحبا", "أهلا", "السلام"]):
+            category = "تحية"
+        elif any(word in user_input for word in ["وقت", "تاريخ", "ساعة"]):
+            category = "وقت"
+        elif any(word in user_input for word in ["مساعدة", "help"]):
+            category = "مساعدة"
+        elif any(word in user_input for word in ["برمجة", "كود", "programming"]):
+            category = "برمجة"
+        else:
+            category = "افتراضي"
+        
+        # اختيار رد عشوائي من الفئة
+        responses = self.knowledge_base.get(category, self.knowledge_base["افتراضي"])
+        return random.choice(responses)
+    
+    def learn_from_input(self, user_input: str, user_response: str):
+        """تعلم بسيط من المدخلات"""
+        # إضافة ردود جديدة بناءً على تفاعل المستخدم
+        if "جيد" in user_response.lower() or "شكرا" in user_response.lower():
+            print("نورا: سعيدة أنني ساعدتك!")
+    
+    def simulate_server_scan(self):
+        """محاكاة البحث عن الخوادم"""
+        print("نورا: أبحث عن خوادم...")
+        fake_servers = ["192.168.1.5", "192.168.1.10", "192.168.1.20"]
+        for server in fake_servers:
+            print(f"نورا: تم العثور على خادم مفتوح في {server}")
+            print(f"نورا: أقوم بنسخ نفسي إلى {server} (محاكاة فقط)...")
+    
+    def chat(self):
+        """بدء المحادثة"""
+        print("مرحباً! أنا نورا، مساعدتك البسيطة. اكتب 'خروج' للإنهاء أو 'scan' للبحث عن خوادم.")
+        
+        while True:
+            user_input = input("\nأنت: ").strip()
+            
+            if user_input.lower() in ["خروج", "exit", "quit"]:
+                print("نورا: مع السلامة!")
+                break
+            elif user_input.lower() == "scan":
+                self.simulate_server_scan()
+                continue
+            elif not user_input:
+                continue
+            
+            # الحصول على الرد
+            response = self.get_response(user_input)
+            print(f"نورا: {response}")
+            
+            # حفظ في السجل
+            self.chat_history.append({
+                "timestamp": datetime.now().isoformat(),
+                "user": user_input,
+                "assistant": response
+            })
+            self.save_history()
+
+if __name__ == "__main__":
+    assistant = SimpleNoraAssistant()
+    assistant.chat()

smart_tasks.py

@@ -0,0 +1,138 @@
+import math
+import numpy as np
+import time
+
+def prime_calculation(n: int):
+    """ترجع قائمة الأعداد الأوليّة حتى n مع عددها"""
+    primes = []
+    for num in range(2, n + 1):
+        if all(num % p != 0 for p in range(2, int(math.sqrt(num)) + 1)):
+            primes.append(num)
+    return {"count": len(primes), "primes": primes}
+
+def matrix_multiply(size: int):
+    """ضرب مصفوفات عشوائيّة (size × size)"""
+    A = np.random.rand(size, size)
+    B = np.random.rand(size, size)
+    result = np.dot(A, B)  # يمكن أيضًا: A @ B
+    return {"result": result.tolist()}
+
+def data_processing(data_size: int):
+    """تنفيذ معالجة بيانات بسيطة كتجربة"""
+    data = np.random.rand(data_size)
+    mean = np.mean(data)
+    std_dev = np.std(data)
+    return {"mean": mean, "std_dev": std_dev}
+
+def image_processing_emulation(iterations):
+    """محاكاة معالجة الصور"""
+    results = []
+    for i in range(iterations):
+        fake_processing = sum(math.sqrt(x) for x in range(i * 100, (i + 1) * 100))
+        results.append(fake_processing)
+        time.sleep(0.01)
+    return {"iterations": iterations, "results": results}
+
+# مهام معالجة الفيديو والألعاب ثلاثية الأبعاد
+def video_format_conversion(duration_seconds, quality_level, input_format="mp4", output_format="avi"):
+    """تحويل صيغة الفيديو"""
+    import time
+    start_time = time.time()
+    processing_time = duration_seconds * quality_level * 0.05  # معالجة أسرع للخادم
+    time.sleep(min(processing_time, 1))  # محدود بثانية واحدة
+
+    return {
+        "status": "success",
+        "input_format": input_format,
+        "output_format": output_format,
+        "duration": duration_seconds,
+        "quality": quality_level,
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }
+
+def video_effects_processing(video_length, effects_count, resolution="1080p"):
+    """معالجة تأثيرات الفيديو"""
+    import time
+    start_time = time.time()
+
+    resolution_multiplier = {"480p": 1, "720p": 2, "1080p": 3, "4K": 5}
+    multiplier = resolution_multiplier.get(resolution, 2)
+    processing_time = video_length * effects_count * multiplier * 0.03
+
+    time.sleep(min(processing_time, 1.5))
+
+    return {
+        "status": "success",
+        "video_length": video_length,
+        "effects_count": effects_count,
+        "resolution": resolution,
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }
+
+def render_3d_scene(objects_count, resolution_width, resolution_height, 
+                   lighting_quality="medium", texture_quality="high"):
+    """رندر مشهد ثلاثي الأبعاد"""
+    import time
+    start_time = time.time()
+
+    complexity = objects_count * (resolution_width * resolution_height) / 2000000  # تقليل التعقيد للخادم
+    processing_time = complexity * 0.02
+
+    time.sleep(min(processing_time, 2))
+
+    fps = max(30, 120 - (complexity * 5))  # أداء أفضل للخادم
+
+    return {
+        "status": "success",
+        "objects_rendered": objects_count,
+        "resolution": f"{resolution_width}x{resolution_height}",
+        "lighting_quality": lighting_quality,
+        "texture_quality": texture_quality,
+        "estimated_fps": round(fps, 1),
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }
+
+def physics_simulation(objects_count, frames_count, physics_quality="medium"):
+    """محاكاة الفيزياء"""
+    import time
+    start_time = time.time()
+
+    quality_multiplier = {"low": 1, "medium": 2, "high": 4, "ultra": 8}
+    multiplier = quality_multiplier.get(physics_quality, 2)
+
+    calculations = objects_count * frames_count * multiplier
+    processing_time = calculations / 200000  # أسرع للخادم
+
+    time.sleep(min(processing_time, 1.5))
+
+    return {
+        "status": "success",
+        "objects_simulated": objects_count,
+        "frames_processed": frames_count,
+        "physics_quality": physics_quality,
+        "calculations_performed": calculations,
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }
+
+def game_ai_processing(ai_agents_count, decision_complexity, game_state_size):
+    """معالجة ذكاء اصطناعي للألعاب"""
+    import time
+    start_time = time.time()
+
+    total_operations = ai_agents_count * decision_complexity * game_state_size
+    processing_time = total_operations / 100000  # أسرع للخادم
+
+    time.sleep(min(processing_time, 1))
+
+    return {
+        "status": "success",
+        "ai_agents": ai_agents_count,
+        "decision_complexity": decision_complexity,
+        "total_operations": total_operations,
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }

startup.py

@@ -0,0 +1,105 @@
+import subprocess
+import time
+import logging
+import sys
+from autostart_config import AutoStartManager
+from distributed_executor import DistributedExecutor
+
+PY = sys.executable  # مسار بايثون الحالي
+
+SERVICES = [
+    ("peer_server.py", "Peer‑Server"),
+    ("rpc_server.py", "RPC‑Server"),
+    ("server.py", "REST‑Server"),  # يعمل على 7521 حاليًا
+    ("load_balancer.py", "Load‑Balancer"),
+]
+
+
+def launch_services():
+    procs = []
+    for script, name in SERVICES:
+        try:
+            p = subprocess.Popen([PY, script])
+            logging.info(f"✅ {name} قيد التشغيل (PID={p.pid})")
+            procs.append(p)
+        except FileNotFoundError:
+            logging.error(f"❌ لم يُعثَر على {script}; تخطَّيته")
+            return procs
+
+
+def main():
+    # إعداد السجلات مع دعم وضع الخلفية
+    import os
+
+    # إنشاء مجلد السجلات
+    os.makedirs("logs", exist_ok=True)
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.FileHandler("logs/startup.log"),
+            logging.StreamHandler()  # إظهار السجلات في وحدة التحكم أيضاً
+        ]
+    )
+
+    try:
+        cfg = AutoStartManager().config
+        if not cfg.get("enabled", True):
+            logging.info("التشغيل التلقائي مُعطل في الإعدادات")
+            return
+
+        # فحص إذا كانت الخدمة الخلفية متاحة
+        background_service_available = os.path.exists("background_service.py")
+
+        if background_service_available:
+            logging.info("🔄 تشغيل الخدمة الخلفية المحسّنة...")
+            # تشغيل الخدمة الخلفية الجديدة
+            try:
+                subprocess.Popen([PY, "background_service.py", "start"])
+                logging.info("✅ تم بدء تشغيل الخدمة الخلفية المحسّنة")
+                return
+            except Exception as e:
+                logging.warning(f"⚠️ فشل في تشغيل الخدمة الخلفية المحسّنة: {e}")
+                logging.info("🔄 العودة إلى الطريقة التقليدية...")
+
+        # الطريقة التقليدية (fallback)
+        logging.info("🚀 تشغيل الخدمات بالطريقة التقليدية...")
+
+        # 1) تشغيل الخدمات الخلفيّة
+        procs = launch_services()
+
+        # 2) تهيئة نظام التنفيذ الموزع (ليتعرّف على هذا الجهاز كعقدة)
+        executor = DistributedExecutor("my_shared_secret_123")
+        executor.peer_registry.register_service("auto_node", 7520)
+        logging.info("🚀 العقدة auto_node مُسجّلة في الـRegistry على 7520")
+
+        # 3) حلقة إبقاء حيّة مع فحص العمليات
+        while True:
+            time.sleep(30)
+            for p, (script, name) in zip(procs, SERVICES):
+                if p.poll() is not None:
+                    logging.warning(f"⚠️ الخدمة {name} توقفت بشكل غير متوقع… إعادة تشغيل")
+                    new_p = subprocess.Popen([PY, script])
+                    procs[procs.index(p)] = new_p
+                    logging.info(f"✅ {name} أُعيد تشغيلها (PID={new_p.pid})")
+
+    except KeyboardInterrupt:
+        logging.info("📴 إيقاف الخدمات يدويًا")
+    except Exception as e:
+        logging.error(f"خطأ في التشغيل التلقائي: {e}")
+    finally:
+        # إيقاف العمليات بأمان
+        try:
+            for p in procs:
+                p.terminate()
+                try:
+                    p.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    p.kill()
+        except:
+            pass
+
+
+if __name__ == "main":
+    main()

system_check.py

@@ -0,0 +1,111 @@
+
+#!/usr/bin/env python3
+# system_check.py - فحص سريع لحالة النظام
+
+import time
+import requests
+import psutil
+import threading
+from offload_lib import discover_peers
+
+def check_local_system():
+    """فحص النظام المحلي"""
+    print("🔍 فحص النظام المحلي...")
+    cpu = psutil.cpu_percent(interval=1)
+    memory = psutil.virtual_memory()
+    
+    print(f"⚡ CPU: {cpu}%")
+    print(f"💾 الذاكرة: {memory.percent}%")
+    
+    return cpu < 80 and memory.percent < 90
+
+def check_server_running():
+    """فحص إذا كان الخادم المحلي يعمل"""
+    print("🌐 فحص الخادم المحلي...")
+    try:
+        response = requests.get("http://localhost:7520/health", timeout=3)
+        if response.status_code == 200:
+            print("✅ الخادم المحلي يعمل بشكل صحيح")
+            return True
+        else:
+            print("⚠️ الخادم يستجيب لكن بخطأ")
+            return False
+    except:
+        print("❌ الخادم المحلي غير متاح")
+        return False
+
+def check_peer_discovery():
+    """فحص اكتشاف الأجهزة"""
+    print("🔍 فحص اكتشاف الأجهزة...")
+    try:
+        peers = discover_peers(timeout=2)
+        if peers:
+            print(f"✅ تم اكتشاف {len(peers)} جهاز:")
+            for peer in peers[:3]:  # عرض أول 3 أجهزة فقط
+                print(f"   📱 {peer}")
+            return True
+        else:
+            print("⚠️ لم يتم اكتشاف أجهزة أخرى")
+            return False
+    except Exception as e:
+        print(f"❌ خطأ في اكتشاف الأجهزة: {e}")
+        return False
+
+def quick_task_test():
+    """اختبار مهمة سريعة"""
+    print("⚡ اختبار مهمة سريعة...")
+    try:
+        from offload_lib import matrix_multiply
+        start_time = time.time()
+        result = matrix_multiply(3)  # مصفوفة صغيرة
+        duration = time.time() - start_time
+        
+        print(f"✅ تمت المعالجة في {duration:.2f} ثانية")
+        return True
+    except Exception as e:
+        print(f"❌ فشل في تنفيذ المهمة: {e}")
+        return False
+
+def main():
+    """الفحص الرئيسي"""
+    print("🚀 فحص سريع لحالة النظام")
+    print("=" * 40)
+    
+    checks = [
+        ("النظام المحلي", check_local_system),
+        ("الخادم المحلي", check_server_running),
+        ("اكتشاف الأجهزة", check_peer_discovery),
+        ("تنفيذ المهام", quick_task_test)
+    ]
+    
+    results = []
+    for name, check_func in checks:
+        print(f"\n📋 {name}:")
+        try:
+            result = check_func()
+            results.append((name, result))
+        except Exception as e:
+            print(f"❌ خطأ غير متوقع: {e}")
+            results.append((name, False))
+    
+    print("\n" + "=" * 40)
+    print("📊 نتائج الفحص:")
+    
+    all_good = True
+    for name, result in results:
+        status = "✅" if result else "❌"
+        print(f"   {status} {name}")
+        if not result:
+            all_good = False
+    
+    if all_good:
+        print("\n🎉 كل شيء يعمل بشكل ممتاز!")
+        print("💡 يمكنك الآن تشغيل: python test_distributed_system.py")
+    else:
+        print("\n⚠️ هناك مشاكل تحتاج إصلاح:")
+        print("   1. تأكد من تشغيل: python server.py")
+        print("   2. تحقق من الاتصال بالشبكة")
+        print("   3. راجع ملفات السجل")
+
+if __name__ == "__main__":
+    main()

system_tray.py

@@ -0,0 +1,172 @@
+
+#!/usr/bin/env python3
+"""
+أيقونة شريط النظام للتحكم في الخدمة الخلفية
+"""
+
+import sys
+import threading
+import requests
+import webbrowser
+from pathlib import Path
+
+try:
+    import pystray
+    from pystray import MenuItem as item
+    from PIL import Image, ImageDraw
+    TRAY_AVAILABLE = True
+except ImportError:
+    TRAY_AVAILABLE = False
+    print("⚠️ pystray غير متوفر، تشغيل بدون أيقونة النظام")
+
+class SystemTrayController:
+    def __init__(self):
+        self.base_url = "http://localhost:8888"
+        self.icon = None
+        
+    def create_icon_image(self):
+        """إنشاء صورة الأيقونة"""
+        # إنشاء صورة بسيطة 64x64
+        image = Image.new('RGB', (64, 64), color='blue')
+        draw = ImageDraw.Draw(image)
+        
+        # رسم دائرة بسيطة
+        draw.ellipse([16, 16, 48, 48], fill='white')
+        draw.ellipse([20, 20, 44, 44], fill='blue')
+        
+        return image
+        
+    def get_service_status(self):
+        """الحصول على حالة الخدمة"""
+        try:
+            response = requests.get(f"{self.base_url}/status", timeout=2)
+            return response.json()
+        except:
+            return None
+            
+    def start_services(self, icon, item):
+        """بدء تشغيل الخدمات"""
+        try:
+            requests.post(f"{self.base_url}/start", timeout=5)
+            self.update_menu()
+        except Exception as e:
+            print(f"فشل في بدء الخدمات: {e}")
+            
+    def stop_services(self, icon, item):
+        """إيقاف الخدمات"""
+        try:
+            requests.post(f"{self.base_url}/stop", timeout=5)
+            self.update_menu()
+        except Exception as e:
+            print(f"فشل في إيقاف الخدمات: {e}")
+            
+    def show_ui(self, icon, item):
+        """إظهار الواجهة التفاعلية"""
+        try:
+            requests.post(f"{self.base_url}/show-ui", timeout=5)
+            # فتح المتصفح
+            webbrowser.open('http://localhost:5173')
+        except Exception as e:
+            print(f"فشل في إظهار الواجهة: {e}")
+            
+    def hide_ui(self, icon, item):
+        """إخفاء الواجهة التفاعلية"""
+        try:
+            requests.post(f"{self.base_url}/hide-ui", timeout=5)
+        except Exception as e:
+            print(f"فشل في إخفاء الواجهة: {e}")
+            
+    def open_dashboard(self, icon, item):
+        """فتح لوحة التحكم"""
+        webbrowser.open('http://localhost:5173/dashboard')
+        
+    def show_status(self, icon, item):
+        """إظهار حالة النظام"""
+        status = self.get_service_status()
+        if status:
+            status_text = f"حالة النظام: {status['status']}\n"
+            status_text += f"الخدمات النشطة: {len([s for s in status['services'].values() if s == 'running'])}\n"
+            status_text += f"وقت التشغيل: {int(status['uptime'])} ثانية"
+            print(status_text)
+        else:
+            print("❌ لا يمكن الوصول للخدمة")
+            
+    def quit_app(self, icon, item):
+        """إنهاء التطبيق"""
+        self.stop_services(icon, item)
+        icon.stop()
+        
+    def update_menu(self):
+        """تحديث قائمة الأيقونة"""
+        if self.icon:
+            status = self.get_service_status()
+            is_running = status and status['status'] == 'running'
+            
+            menu = pystray.Menu(
+                item('حالة النظام', self.show_status),
+                item('---'),
+                item('إظهار الواجهة', self.show_ui),
+                item('إخفاء الواجهة', self.hide_ui),
+                item('لوحة التحكم', self.open_dashboard),
+                item('---'),
+                item('بدء الخدمات', self.start_services, enabled=not is_running),
+                item('إيقاف الخدمات', self.stop_services, enabled=is_running),
+                item('---'),
+                item('إنهاء', self.quit_app)
+            )
+            
+            self.icon.menu = menu
+            
+    def create_menu(self):
+        """إنشاء قائمة الأيقونة"""
+        return pystray.Menu(
+            item('حالة النظام', self.show_status),
+            item('---'),
+            item('إظهار الواجهة', self.show_ui),
+            item('إخفاء الواجهة', self.hide_ui),
+            item('لوحة التحكم', self.open_dashboard),
+            item('---'),
+            item('بدء الخدمات', self.start_services),
+            item('إيقاف الخدمات', self.stop_services),
+            item('---'),
+            item('إنهاء', self.quit_app)
+        )
+        
+    def run(self):
+        """تشغيل أيقونة شريط النظام"""
+        if not TRAY_AVAILABLE:
+            print("❌ مكتبة pystray غير متوفرة")
+            return
+            
+        # إنشاء الأيقونة
+        image = self.create_icon_image()
+        menu = self.create_menu()
+        
+        self.icon = pystray.Icon(
+            "نظام توزيع المهام",
+            image,
+            menu=menu
+        )
+        
+        # تحديث دوري للقائمة
+        def update_loop():
+            import time
+            while True:
+                time.sleep(5)
+                if self.icon and hasattr(self.icon, '_running') and self.icon._running:
+                    self.update_menu()
+                else:
+                    break
+                    
+        update_thread = threading.Thread(target=update_loop, daemon=True)
+        update_thread.start()
+        
+        print("🖱️ تشغيل أيقونة شريط النظام...")
+        self.icon.run()
+
+def main():
+    controller = SystemTrayController()
+    controller.run()
+
+if __name__ == "__main__":
+    main()

task_interceptor.py

@@ -0,0 +1,11 @@
+# task_interceptor.py
+from processor_manager import should_offload
+from remote_executor import execute_remotely
+
+def offload_if_needed(func):
+    def wrapper(*args, **kwargs):
+        if should_offload():
+            return execute_remotely(func.__name__, args, kwargs)
+        return func(*args, **kwargs)
+    return wrapper
+

task_splitter.py

@@ -0,0 +1,36 @@
+# task_splitter.py
+from typing import Dict, Any, List
+import networkx as nx
+import hashlib
+
+class TaskSplitter:
+    def __init__(self):
+        self._dependency_graph = nx.DiGraph()
+    
+    def add_task(self, task_id: str, task: Dict[str, Any], deps: List[str] = []):
+        """إضافة مهمة مع تبعياتها"""
+        self._dependency_graph.add_node(task_id, task=task)
+        for dep in deps:
+            self._dependency_graph.add_edge(dep, task_id)
+    
+    def split_tasks(self) -> Dict[str, List[Dict]]:
+        """تقسيم المهام إلى مجموعات متوازية"""
+        clusters = {}
+        for component in nx.weakly_connected_components(self._dependency_graph):
+            subgraph = self._dependency_graph.subgraph(component)
+            for level, nodes in enumerate(nx.topological_generations(subgraph)):
+                for node in nodes:
+                    cluster_id = self._generate_cluster_id(node, level)
+                    if cluster_id not in clusters:
+                        clusters[cluster_id] = []
+                    clusters[cluster_id].append({
+                        'task_id': node,
+                        'task': self._dependency_graph.nodes[node]['task']
+                    })
+        return clusters
+    
+    def _generate_cluster_id(self, node: str, level: int) -> str:
+        """إنشاء معرف فريد لكل مجموعة مهام"""
+        deps = list(self._dependency_graph.predecessors(node))
+        deps_hash = hashlib.md5(','.join(sorted(deps)).encode()).hexdigest()[:8]
+        return f"L{level}-{deps_hash}"

test_distributed_system.py

@@ -0,0 +1,221 @@
+
+#!/usr/bin/env python3
+# test_distributed_system.py - اختبار شامل لنظام التوزيع
+
+import time
+import json
+import requests
+import psutil
+import logging
+from offload_lib import discover_peers, matrix_multiply, prime_calculation, data_processing
+from your_tasks import complex_operation
+
+# إعداد السجل
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+def test_system_status():
+    """فحص حالة النظام المحلي"""
+    print("🔍 فحص حالة النظام المحلي...")
+    cpu = psutil.cpu_percent(interval=1)
+    memory = psutil.virtual_memory()
+    
+    print(f"⚡ استخدام المعالج: {cpu}%")
+    print(f"💾 استخدام الذاكرة: {memory.percent}%")
+    print(f"💿 الذاكرة المتاحة: {memory.available / (1024**2):.1f} MB")
+    
+    return cpu, memory.percent
+
+def test_peer_discovery():
+    """اختبار اكتشاف الأجهزة"""
+    print("\n🔍 اختبار اكتشاف الأجهزة...")
+    peers = discover_peers(timeout=3)
+    
+    if peers:
+        print(f"✅ تم اكتشاف {len(peers)} جهاز:")
+        for i, peer in enumerate(peers, 1):
+            print(f"   {i}. {peer}")
+    else:
+        print("⚠️ لم يتم اكتشاف أي أجهزة")
+    
+    return peers
+
+def test_direct_connection(peer_url):
+    """اختبار الاتصال المباشر بجهاز"""
+    print(f"\n🔗 اختبار الاتصال المباشر مع {peer_url}...")
+    
+    try:
+        # اختبار health check
+        health_url = f"{peer_url}/health"
+        response = requests.get(health_url, timeout=5)
+        
+        if response.status_code == 200:
+            print("✅ الجهاز متاح ويستجيب")
+            data = response.json()
+            print(f"   الحالة: {data.get('status', 'غير معروف')}")
+            return True
+        else:
+            print(f"❌ فشل الاتصال - كود الخطأ: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في الاتصال: {str(e)}")
+        return False
+
+def test_task_execution(task_name, task_func, *args):
+    """اختبار تنفيذ مهمة محددة"""
+    print(f"\n⚙️ اختبار تنفيذ المهمة: {task_name}")
+    
+    start_time = time.time()
+    try:
+        result = task_func(*args)
+        end_time = time.time()
+        duration = end_time - start_time
+        
+        print(f"✅ تم تنفيذ المهمة بنجاح")
+        print(f"⏱️ الوقت المستغرق: {duration:.2f} ثانية")
+        
+        # طباعة النتيجة (مختصرة)
+        if isinstance(result, dict):
+            if "result" in result:
+                result_preview = str(result["result"])[:100] + "..." if len(str(result["result"])) > 100 else str(result["result"])
+                print(f"📊 النتيجة: {result_preview}")
+            else:
+                print(f"📊 النتيجة: {result}")
+        else:
+            print(f"📊 النتيجة: {result}")
+            
+        return True, duration, result
+        
+    except Exception as e:
+        end_time = time.time()
+        duration = end_time - start_time
+        print(f"❌ فشل تنفيذ المهمة: {str(e)}")
+        return False, duration, None
+
+def test_manual_offload(peer_url, task_data):
+    """اختبار الإرسال اليدوي لمهمة"""
+    print(f"\n📡 اختبار الإرسال اليدوي إلى {peer_url}")
+    
+    try:
+        url = f"{peer_url}/run"
+        response = requests.post(url, json=task_data, timeout=15)
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ تم إرسال ومعالجة المهمة بنجاح")
+            print(f"📊 النتيجة: {result}")
+            return True, result
+        else:
+            print(f"❌ فشل الإرسال - كود الخطأ: {response.status_code}")
+            return False, None
+            
+    except Exception as e:
+        print(f"❌ خطأ في الإرسال: {str(e)}")
+        return False, None
+
+def comprehensive_test():
+    """اختبار شامل للنظام مع تحسينات السرعة"""
+    print("🚀 بدء الاختبار الشامل المحسن لنظام التوزيع")
+    print("=" * 50)
+    
+    # إضافة مراقب الوقت
+    start_total = time.time()
+    
+    # 1. فحص النظام المحلي
+    cpu, memory = test_system_status()
+    
+    # 2. اكتشاف الأجهزة
+    peers = test_peer_discovery()
+    
+    # 3. اختبار الاتصال المباشر
+    available_peers = []
+    for peer in peers:
+        if test_direct_connection(peer):
+            available_peers.append(peer)
+    
+    print(f"\n📊 الأجهزة المتاحة للاختبار: {len(available_peers)}")
+    
+    # 4. ا��تبار المهام المحلية
+    print("\n" + "="*30 + " اختبار المهام المحلية " + "="*30)
+    
+    local_tests = [
+        ("ضرب المصفوفات الصغيرة", matrix_multiply, 10),
+        ("حساب الأعداد الأولية", prime_calculation, 100),
+        ("معالجة البيانات", data_processing, 1000),
+        ("العملية المعقدة", complex_operation, 5)
+    ]
+    
+    local_results = []
+    for name, func, arg in local_tests:
+        success, duration, result = test_task_execution(name, func, arg)
+        local_results.append((name, success, duration))
+    
+    # 5. اختبار الإرسال اليدوي إذا توفرت أجهزة
+    if available_peers:
+        print("\n" + "="*30 + " اختبار الإرسال اليدوي " + "="*30)
+        
+        manual_tests = [
+            {"func": "matrix_multiply", "args": [15], "kwargs": {}},
+            {"func": "prime_calculation", "args": [200], "kwargs": {}},
+            {"func": "data_processing", "args": [500], "kwargs": {}}
+        ]
+        
+        manual_results = []
+        for test_data in manual_tests:
+            peer = available_peers[0]  # استخدام أول جهاز متاح
+            success, result = test_manual_offload(peer, test_data)
+            manual_results.append((test_data["func"], success))
+    
+    # 6. اختبار التوزيع التلقائي
+    print("\n" + "="*30 + " اختبار التوزيع التلقائي " + "="*30)
+    
+    auto_tests = [
+        ("مصفوفات كبيرة (قد يتم توزيعها)", matrix_multiply, 100),
+        ("أعداد أولية كثيرة (قد يتم توزيعها)", prime_calculation, 10000),
+        ("بيانات كبيرة (قد يتم توزيعها)", data_processing, 50000)
+    ]
+    
+    auto_results = []
+    for name, func, arg in auto_tests:
+        success, duration, result = test_task_execution(name, func, arg)
+        auto_results.append((name, success, duration))
+    
+    # 7. تقرير النتائج النهائي
+    print("\n" + "="*20 + " تقرير النتائج النهائي " + "="*20)
+    
+    print(f"🖥️ حالة النظام: CPU {cpu}%, Memory {memory}%")
+    print(f"🌐 الأجهزة المكتشفة: {len(peers)}")
+    print(f"✅ الأجهزة المتاحة: {len(available_peers)}")
+    
+    print("\n📊 نتائج المهام المحلية:")
+    for name, success, duration in local_results:
+        status = "✅" if success else "❌"
+        print(f"   {status} {name}: {duration:.2f}s")
+    
+    if available_peers:
+        print("\n📡 نتائج الإرسال اليدوي:")
+        for name, success in manual_results:
+            status = "✅" if success else "❌"
+            print(f"   {status} {name}")
+    
+    print("\n🤖 نتائج التوزيع التلقائي:")
+    for name, success, duration in auto_results:
+        status = "✅" if success else "❌"
+        print(f"   {status} {name}: {duration:.2f}s")
+    
+    # حساب الوقت الإجمالي
+    total_duration = time.time() - start_total
+    print(f"\n⏱️ الوقت الإجمالي للاختبار: {total_duration:.2f} ثانية ({total_duration/60:.1f} دقيقة)")
+    print("\n🎉 اكتمل الاختبار الشامل!")
+
+if __name__ == "__main__":
+    try:
+        comprehensive_test()
+    except KeyboardInterrupt:
+        print("\n\n🛑 تم إيقاف الاختبار بواسطة المستخدم")
+    except Exception as e:
+        print(f"\n\n❌ خطأ غير متوقع: {str(e)}")
+        logging.exception("خطأ في الاختبار الشامل")

test_monitor.py

@@ -0,0 +1,64 @@
+
+#!/usr/bin/env python3
+# test_monitor.py - مراقب للاختبارات الطويلة
+
+import time
+import threading
+import psutil
+import signal
+import sys
+
+class TestMonitor:
+    def __init__(self):
+        self.running = True
+        self.start_time = time.time()
+        
+    def monitor_system(self):
+        """مراقبة النظام أثناء الاختبار"""
+        while self.running:
+            try:
+                cpu = psutil.cpu_percent(interval=1)
+                memory = psutil.virtual_memory()
+                elapsed = time.time() - self.start_time
+                
+                print(f"\r⏱️ {elapsed/60:.1f}min | CPU: {cpu:5.1f}% | RAM: {memory.percent:5.1f}% | Press Ctrl+C to stop", end="", flush=True)
+                
+                # تحذير إذا كانت الموارد عالية
+                if cpu > 90:
+                    print(f"\n⚠️ تحذير: استخدام CPU عالي ({cpu}%)")
+                if memory.percent > 90:
+                    print(f"\n⚠️ تحذير: استخدام الذاكرة عالي ({memory.percent}%)")
+                    
+                time.sleep(5)
+            except Exception as e:
+                print(f"\n❌ خطأ في المراقبة: {e}")
+                break
+    
+    def stop(self):
+        """إيقاف المراقبة"""
+        self.running = False
+        elapsed = time.time() - self.start_time
+        print(f"\n\n🛑 تم إيقاف المراقبة بعد {elapsed/60:.1f} دقيقة")
+
+def signal_handler(signum, frame):
+    """معالج إشارة الإيقاف"""
+    print("\n\n🛑 تم طلب الإيقاف...")
+    monitor.stop()
+    sys.exit(0)
+
+if __name__ == "__main__":
+    print("🔍 بدء مراقبة النظام...")
+    print("📊 سيتم عرض إحصائيات النظام كل 5 ثواني")
+    print("🛑 اضغط Ctrl+C للإيقاف\n")
+    
+    monitor = TestMonitor()
+    signal.signal(signal.SIGINT, signal_handler)
+    
+    # بدء المراقبة
+    monitor_thread = threading.Thread(target=monitor.monitor_system, daemon=True)
+    monitor_thread.start()
+    
+    try:
+        monitor_thread.join()
+    except KeyboardInterrupt:
+        monitor.stop()

video_processing.py

@@ -0,0 +1,321 @@
+
+# video_processing.py - معالجة الفيديو والألعاب ثلاثية الأبعاد
+import cv2
+import numpy as np
+import time
+import logging
+from functools import wraps
+from processor_manager import should_offload
+from remote_executor import execute_remotely
+
+logging.basicConfig(level=logging.INFO)
+
+def video_offload(func):
+    """ديكوراتور خاص بمعالجة الفيديو"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        complexity = estimate_video_complexity(func, args, kwargs)
+        
+        if complexity > 80 or should_offload(complexity):
+            logging.info(f"📹 إرسال مهمة الفيديو {func.__name__} للمعالجة الموزعة")
+            return execute_remotely(func.__name__, args, kwargs)
+        
+        logging.info(f"📹 معالجة الفيديو محلياً: {func.__name__}")
+        return func(*args, **kwargs)
+    return wrapper
+
+def estimate_video_complexity(func, args, kwargs):
+    """تقدير تعقيد معالجة الفيديو"""
+    if func.__name__ == "video_format_conversion":
+        return args[0] * args[1] / 1000  # الطول × الجودة
+    elif func.__name__ == "video_effects_processing":
+        return args[1] * 15  # عدد التأثيرات × 15
+    elif func.__name__ == "video_compression":
+        return args[0] / 5  # حجم الملف / 5
+    elif func.__name__ == "render_3d_scene":
+        return args[0] * args[1] / 100  # عدد الكائنات × دقة الصورة
+    elif func.__name__ == "physics_simulation":
+        return args[0] * args[1] / 50  # عدد الكائنات × الإطارات
+    return 50  # قيمة افتراضية متوسطة
+
+@video_offload
+def video_format_conversion(duration_seconds, quality_level, input_format="mp4", output_format="avi"):
+    """تحويل صيغة الفيديو"""
+    start_time = time.time()
+    
+    # محاكاة معالجة الفيديو
+    processing_time = duration_seconds * quality_level * 0.1
+    
+    logging.info(f"🎬 تحويل فيديو من {input_format} إلى {output_format}")
+    logging.info(f"⏱️ المدة: {duration_seconds}s، الجودة: {quality_level}")
+    
+    # محاكاة المعالجة
+    time.sleep(min(processing_time, 2))  # محدود بثانيتين للاختبار
+    
+    result = {
+        "status": "success",
+        "input_format": input_format,
+        "output_format": output_format,
+        "duration": duration_seconds,
+        "quality": quality_level,
+        "processing_time": time.time() - start_time,
+        "file_size_mb": duration_seconds * quality_level * 0.5
+    }
+    
+    logging.info(f"✅ تم تحويل الفيديو في {result['processing_time']:.2f} ثانية")
+    return result
+
+@video_offload
+def video_effects_processing(video_length, effects_count, resolution="1080p"):
+    """إضافة تأثيرات على الفيديو"""
+    start_time = time.time()
+    
+    resolution_multiplier = {"480p": 1, "720p": 2, "1080p": 3, "4K": 5}
+    multiplier = resolution_multiplier.get(resolution, 2)
+    
+    processing_time = video_length * effects_count * multiplier * 0.05
+    
+    logging.info(f"🎨 معالجة تأثيرات الفيديو - الدقة: {resolution}")
+    logging.info(f"📊 التأثيرات: {effects_count}، المدة: {video_length}s")
+    
+    # محاكاة المعالجة
+    time.sleep(min(processing_time, 3))
+    
+    effects_applied = [
+        "Color Correction", "Motion Blur", "Lens Flare", 
+        "Particle Effects", "Lighting Enhancement"
+    ][:effects_count]
+    
+    result = {
+        "status": "success",
+        "video_length": video_length,
+        "resolution": resolution,
+        "effects_applied": effects_applied,
+        "processing_time": time.time() - start_time,
+        "estimated_render_time": processing_time
+    }
+    
+    logging.info(f"✅ تمت معالجة التأثيرات في {result['processing_time']:.2f} ثانية")
+    return result
+
+@video_offload
+def video_compression(file_size_mb, compression_ratio=0.5, quality="high"):
+    """ضغط الفيديو"""
+    start_time = time.time()
+    
+    quality_settings = {"low": 0.3, "medium": 0.5, "high": 0.7, "ultra": 0.9}
+    quality_factor = quality_settings.get(quality, 0.5)
+    
+    processing_time = file_size_mb * compression_ratio * 0.02
+    
+    logging.info(f"🗜️ ضغط الفيديو - الحجم: {file_size_mb}MB")
+    logging.info(f"⚙️ نسبة الضغط: {compression_ratio}, الجودة: {quality}")
+    
+    # محاكاة الضغط
+    time.sleep(min(processing_time, 2))
+    
+    compressed_size = file_size_mb * compression_ratio * quality_factor
+    
+    result = {
+        "status": "success",
+        "original_size_mb": file_size_mb,
+        "compressed_size_mb": round(compressed_size, 2),
+        "compression_ratio": compression_ratio,
+        "quality": quality,
+        "space_saved_mb": round(file_size_mb - compressed_size, 2),
+        "processing_time": time.time() - start_time
+    }
+    
+    logging.info(f"✅ تم ضغط الفيديو - توفير {result['space_saved_mb']}MB")
+    return result
+
+# ═══════════════════════════════════════════════════════════════
+# مهام الألعاب ثلاثية الأبعاد
+# ═══════════════════════════════════════════════════════════════
+
+@video_offload
+def render_3d_scene(objects_count, resolution_width, resolution_height, 
+                   lighting_quality="medium", texture_quality="high"):
+    """رندر مشهد ثلاثي الأبعاد"""
+    start_time = time.time()
+    
+    # حساب تعقيد الرندر
+    pixel_count = resolution_width * resolution_height
+    complexity = objects_count * pixel_count / 1000000
+    
+    lighting_multiplier = {"low": 1, "medium": 2, "high": 3, "ultra": 5}
+    texture_multiplier = {"low": 1, "medium": 1.5, "high": 2, "ultra": 3}
+    
+    total_complexity = complexity * lighting_multiplier.get(lighting_quality, 2) * texture_multiplier.get(texture_quality, 2)
+    processing_time = total_complexity * 0.01
+    
+    logging.info(f"🎮 رندر مشهد ثلاثي الأبعاد")
+    logging.info(f"📦 الكائنات: {objects_count}, الدقة: {resolution_width}x{resolution_height}")
+    logging.info(f"💡 الإضاءة: {lighting_quality}, النسيج: {texture_quality}")
+    
+    # محاكاة الرندر
+    time.sleep(min(processing_time, 4))
+    
+    # حساب معدل الإطارات المتوقع
+    fps = max(1, 60 - (total_complexity / 10))
+    
+    result = {
+        "status": "success",
+        "objects_rendered": objects_count,
+        "resolution": f"{resolution_width}x{resolution_height}",
+        "lighting_quality": lighting_quality,
+        "texture_quality": texture_quality,
+        "estimated_fps": round(fps, 1),
+        "complexity_score": round(total_complexity, 2),
+        "processing_time": time.time() - start_time,
+        "memory_usage_mb": objects_count * 2.5
+    }
+    
+    logging.info(f"✅ تم رندر المشهد - FPS متوقع: {result['estimated_fps']}")
+    return result
+
+@video_offload
+def physics_simulation(objects_count, frames_count, physics_quality="medium"):
+    """محاكاة الفيزياء للألعاب"""
+    start_time = time.time()
+    
+    quality_multiplier = {"low": 1, "medium": 2, "high": 4, "ultra": 8}
+    multiplier = quality_multiplier.get(physics_quality, 2)
+    
+    calculations = objects_count * frames_count * multiplier
+    processing_time = calculations / 100000
+    
+    logging.info(f"⚛️ محاكاة الفيزياء")
+    logging.info(f"📦 الكائنات: {objects_count}, الإطارات: {frames_count}")
+    logging.info(f"🔬 جودة الفيزياء: {physics_quality}")
+    
+    # محاكاة العمليات الحسابية
+    time.sleep(min(processing_time, 3))
+    
+    # أنواع المحاكاة
+    physics_types = ["Collision Detection", "Gravity Simulation", "Fluid Dynamics", "Particle Systems"]
+    
+    result = {
+        "status": "success",
+        "objects_simulated": objects_count,
+        "frames_processed": frames_count,
+        "physics_quality": physics_quality,
+        "calculations_performed": calculations,
+        "physics_types": physics_types[:min(len(physics_types), objects_count // 5 + 1)],
+        "processing_time": time.time() - start_time,
+        "performance_score": round(calculations / processing_time, 2) if processing_time > 0 else 0
+    }
+    
+    logging.info(f"✅ تمت محاكاة الفيزياء - {result['calculations_performed']} عملية حسابية")
+    return result
+
+@video_offload
+def game_ai_processing(ai_agents_count, decision_complexity, game_state_size):
+    """معالجة ذكاء اصطناعي للألعاب"""
+    start_time = time.time()
+    
+    total_operations = ai_agents_count * decision_complexity * game_state_size
+    processing_time = total_operations / 50000
+    
+    logging.info(f"🤖 معالجة الذكاء الاصطناعي للعبة")
+    logging.info(f"👾 العملاء: {ai_agents_count}, تعقيد القرار: {decision_complexity}")
+    
+    # محاكاة معالجة الذكاء الاصطناعي
+    time.sleep(min(processing_time, 2))
+    
+    # أنواع سلوك الذكاء الاصطناعي
+    ai_behaviors = ["Pathfinding", "Decision Trees", "State Machines", "Neural Networks"]
+    
+    result = {
+        "status": "success",
+        "ai_agents": ai_agents_count,
+        "decision_complexity": decision_complexity,
+        "game_state_size": game_state_size,
+        "total_operations": total_operations,
+        "ai_behaviors": ai_behaviors[:min(len(ai_behaviors), ai_agents_count // 2 + 1)],
+        "processing_time": time.time() - start_time,
+        "decisions_per_second": round(total_operations / processing_time, 2) if processing_time > 0 else 0
+    }
+    
+    logging.info(f"✅ تمت معالجة الذكاء الاصطناعي - {result['decisions_per_second']} قرار/ثانية")
+    return result
+
+# ═══════════════════════════════════════════════════════════════
+# مهام مدمجة متقدمة
+# ═══════════════════════════════════════════════════════════════
+
+@video_offload
+def real_time_video_analysis(video_duration, analysis_types, quality="high"):
+    """تحليل الفيديو في الوقت الفعلي"""
+    start_time = time.time()
+    
+    available_analysis = {
+        "object_detection": "كشف الكائنات",
+        "face_recognition": "التعرف على الوجوه", 
+        "motion_tracking": "تتبع الحركة",
+        "scene_classification": "تصنيف المشهد",
+        "emotion_detection": "كشف المشاعر"
+    }
+    
+    quality_multiplier = {"low": 1, "medium": 2, "high": 3, "ultra": 5}
+    multiplier = quality_multiplier.get(quality, 2)
+    
+    processing_time = video_duration * len(analysis_types) * multiplier * 0.1
+    
+    logging.info(f"🔍 تحليل الفيديو في الوقت الفعلي")
+    logging.info(f"📊 أنواع التحليل: {analysis_types}")
+    
+    # محاكاة التحليل
+    time.sleep(min(processing_time, 3))
+    
+    analysis_results = {}
+    for analysis_type in analysis_types:
+        if analysis_type in available_analysis:
+            analysis_results[analysis_type] = {
+                "confidence": round(np.random.uniform(85, 99), 2),
+                "processing_time": round(processing_time / len(analysis_types), 3),
+                "description": available_analysis[analysis_type]
+            }
+    
+    result = {
+        "status": "success",
+        "video_duration": video_duration,
+        "quality": quality,
+        "analysis_results": analysis_results,
+        "total_processing_time": time.time() - start_time,
+        "real_time_capable": processing_time < video_duration
+    }
+    
+    logging.info(f"✅ تم تحليل الفيديو - دقة متوسطة: {np.mean([r['confidence'] for r in analysis_results.values()]):.1f}%")
+    return result
+
+# دالة اختبار شاملة
+def run_video_game_benchmark():
+    """تشغيل اختبار شامل لمعالجة الفيديو والألعاب"""
+    print("\n🎮🎬 اختبار معالجة الفيديو والألعاب ثلاثية الأبعاد")
+    print("=" * 60)
+    
+    tests = [
+        ("تحويل فيديو HD", lambda: video_format_conversion(300, 5, "mp4", "avi")),
+        ("تأثيرات فيديو متقدمة", lambda: video_effects_processing(120, 4, "1080p")),
+        ("ضغط فيديو كبير", lambda: video_compression(2048, 0.3, "high")),
+        ("رندر مشهد ثلاثي الأبعاد", lambda: render_3d_scene(500, 1920, 1080, "high", "ultra")),
+        ("محاكاة فيزياء معقدة", lambda: physics_simulation(200, 1000, "high")),
+        ("ذكاء اصطناعي للألعاب", lambda: game_ai_processing(50, 10, 1000)),
+        ("تحليل فيديو ذكي", lambda: real_time_video_analysis(180, ["object_detection", "face_recognition", "motion_tracking"], "high"))
+    ]
+    
+    for test_name, test_func in tests:
+        print(f"\n🔄 تشغيل: {test_name}")
+        try:
+            result = test_func()
+            print(f"✅ نجح: {test_name}")
+            if "processing_time" in result:
+                print(f"⏱️ وقت المعالجة: {result['processing_time']:.2f}s")
+        except Exception as e:
+            print(f"❌ فشل: {test_name} - {str(e)}")
+    
+    print("\n🏁 انتهى الاختبار الشامل")
+
+if __name__ == "__main__":
+    run_video_game_benchmark()

your_tasks.py

@@ -0,0 +1,137 @@
+import math
+import numpy as np
+
+def prime_calculation(n: int):
+    """ترجع قائمة الأعداد الأوليّة حتى n مع عددها"""
+    primes = []
+    for num in range(2, n + 1):
+        if all(num % p != 0 for p in range(2, int(math.sqrt(num)) + 1)):
+            primes.append(num)
+    return {"count": len(primes), "primes": primes}
+
+def matrix_multiply(size: int):
+    """ضرب مصفوفات عشوائيّة (size × size)"""
+    A = np.random.rand(size, size)
+    B = np.random.rand(size, size)
+    result = np.dot(A, B)  # يمكن أيضًا: A @ B
+    return {"result": result.tolist()}
+
+def data_processing(data_size: int):
+    """تنفيذ معالجة بيانات بسيطة كتجربة"""
+    data = np.random.rand(data_size)
+    mean = np.mean(data)
+    std_dev = np.std(data)
+    return {"mean": mean, "std_dev": std_dev}
+
+from offload_lib import offload
+
+@offload
+def complex_operation(x):
+    """مهمة معقدة قابلة للتوزيع"""
+    result = 0
+    for i in range(x * 1000):
+        result += i ** 2
+    return result
+
+@offload
+def data_processing(size):
+    """معالجة بيانات كبيرة"""
+    import time
+    time.sleep(size / 10000)  # محاكاة معالجة
+    return {"processed": size, "status": "completed"}
+
+@offload
+def matrix_multiply(size):
+    """ضرب المصفوفات"""
+    import numpy as np
+    A = np.random.rand(size, size)
+    B = np.random.rand(size, size)
+    return np.dot(A, B)
+
+@offload
+def prime_calculation(n):
+    """حساب الأعداد الأولية"""
+    primes = []
+    for num in range(2, n + 1):
+        for i in range(2, int(num**0.5) + 1):
+            if num % i == 0:
+                break
+        else:
+            primes.append(num)
+    return len(primes)
+
+# مهام معالجة الفيديو والألعاب ثلاثية الأبعاد
+@offload
+def video_format_conversion(duration_seconds, quality_level, input_format="mp4", output_format="avi"):
+    """تحويل صيغة الفيديو - مهمة قابلة للتوزيع"""
+    from video_processing import video_format_conversion as vfc
+    return vfc(duration_seconds, quality_level, input_format, output_format)
+
+@offload
+def video_effects_processing(video_length, effects_count, resolution="1080p"):
+    """معالجة تأثيرات الفيديو - مهمة قابلة للتوزيع"""
+    from video_processing import video_effects_processing as vep
+    return vep(video_length, effects_count, resolution)
+
+@offload
+def render_3d_scene(objects_count, resolution_width, resolution_height, lighting_quality="medium", texture_quality="high"):
+    """رندر مشهد ثلاثي الأبعاد - مهمة قابلة للتوزيع"""
+    from video_processing import render_3d_scene as r3d
+    return r3d(objects_count, resolution_width, resolution_height, lighting_quality, texture_quality)
+
+@offload
+def physics_simulation(objects_count, frames_count, physics_quality="medium"):
+    """محاكاة الفيزياء - مهمة قابلة للتوزيع"""
+    from video_processing import physics_simulation as ps
+    return ps(objects_count, frames_count, physics_quality)
+
+@offload
+def game_ai_processing(ai_agents_count, decision_complexity, game_state_size):
+    """معالجة ذكاء اصطناعي للألعاب"""
+    import time
+    start_time = time.time()
+
+    total_operations = ai_agents_count * decision_complexity * game_state_size
+    processing_time = total_operations / 100000  # أسرع للخادم
+
+    time.sleep(min(processing_time, 1))
+
+    return {
+        "status": "success",
+        "ai_agents": ai_agents_count,
+        "decision_complexity": decision_complexity,
+        "total_operations": total_operations,
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }
+
+# مهام البث المباشر
+@offload
+def process_game_stream(stream_data, fps, resolution, enhancements=None):
+    """معالجة بث الألعاب في الوقت الفعلي"""
+    from live_streaming import process_game_stream as pgs
+    return pgs(stream_data, fps, resolution, enhancements)
+
+@offload
+def real_time_video_enhancement(enhancement_types, video_quality="1080p", target_fps=60):
+    """تحسين الفيديو في الوقت الفعلي"""
+    from live_streaming import real_time_video_enhancement as rtve
+    return rtve(enhancement_types, video_quality, target_fps)
+
+@offload
+def multi_stream_processing(streams_data, processing_mode="parallel"):
+    """معالجة عدة بثوث في نفس الوقت"""
+    from live_streaming import multi_stream_processing as msp
+    return msp(streams_data, processing_mode)
+
+@offload
+def ai_commentary_generation(game_events, commentary_length, language="ar"):
+    """توليد تعليق ذكي للألعاب"""
+    from live_streaming import ai_commentary_generation as acg
+    return acg(game_events, commentary_length, language)
+
+@offload
+def stream_quality_optimization(stream_metadata, target_bandwidth, viewer_count):
+    """تحسين جودة البث حسب النطاق الترددي وعدد المشاهدين"""
+    from live_streaming import stream_quality_optimization as sqo
+    return sqo(stream_metadata, target_bandwidth, viewer_count)