Upload 25 files

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()

buildozer.spec

@@ -0,0 +1,466 @@
+[app]
+
+# (str) Title of your application
+# اسم التطبيق
+title = My Offload App
+
+# اسم الباكيج (فريد)
+package.name = myoffloadapp
+package.domain = org.osama
+
+
+# المتطلبات:
+requirements = python3,kivy,requests,zeroconf,numpy,setuptools
+
+# نسخة API
+android.api = 31
+
+# الحد الأدنى للأندرويد
+android.minapi = 21
+
+# NDK وسكّة البنية
+android.ndk = 25b
+android.sdk = 33
+
+# تفعيل الوصول إلى الإنترنت مثلاً
+android.permissions = INTERNET
+
+# (str) Package domain (needed for android/ios packaging)
+
+# (str) Source code where the main.py live
+source.dir = .
+
+# (list) Source files to include (let empty to include all the files)
+
+# (list) List of inclusions using pattern matching
+#source.include_patterns = assets/*,images/*.png
+
+# (list) Source files to exclude (let empty to not exclude anything)
+#source.exclude_exts = spec
+
+# (list) List of directory to exclude (let empty to not exclude anything)
+#source.exclude_dirs = tests, bin, venv
+
+# (list) List of exclusions using pattern matching
+# Do not prefix with './'
+#source.exclude_patterns = license,images/*/*.jpg
+
+# (str) Application versioning (method 1)
+version = 0.1
+
+# (str) Application versioning (method 2)
+# version.regex = __version__ = ['"](.*)['"]
+# version.filename = %(source.dir)s/main.py
+
+
+# (str) Custom source folders for requirements
+# Sets custom source for any requirements with recipes
+# requirements.source.kivy = ../../kivy
+
+# (str) Presplash of the application
+#presplash.filename = %(source.dir)s/data/presplash.png
+
+# (str) Icon of the application
+#icon.filename = %(source.dir)s/data/icon.png
+
+# (list) Supported orientations
+# Valid options are: landscape, portrait, portrait-reverse or landscape-reverse
+orientation = portrait
+
+# (list) List of service to declare
+#services = NAME:ENTRYPOINT_TO_PY,NAME2:ENTRYPOINT2_TO_PY
+
+#
+# OSX Specific
+#
+
+#
+# author = © Copyright Info
+
+# change the major version of python used by the app
+osx.python_version = 3
+
+# Kivy version to use
+osx.kivy_version = 1.9.1
+
+#
+# Android specific
+#
+
+# (bool) Indicate if the application should be fullscreen or not
+fullscreen = 0
+
+# (string) Presplash background color (for android toolchain)
+# Supported formats are: #RRGGBB #AARRGGBB or one of the following names:
+# red, blue, green, black, white, gray, cyan, magenta, yellow, lightgray,
+# darkgray, grey, lightgrey, darkgrey, aqua, fuchsia, lime, maroon, navy,
+# olive, purple, silver, teal.
+#android.presplash_color = #FFFFFF
+
+# (string) Presplash animation using Lottie format.
+# see https://lottiefiles.com/ for examples and https://airbnb.design/lottie/
+# for general documentation.
+# Lottie files can be created using various tools, like Adobe After Effect or Synfig.
+#android.presplash_lottie = "path/to/lottie/file.json"
+
+# (str) Adaptive icon of the application (used if Android API level is 26+ at runtime)
+#icon.adaptive_foreground.filename = %(source.dir)s/data/icon_fg.png
+#icon.adaptive_background.filename = %(source.dir)s/data/icon_bg.png
+
+# (list) Permissions
+# (See https://python-for-android.readthedocs.io/en/latest/buildoptions/#build-options-1 for all the supported syntaxes and properties)
+#android.permissions = android.permission.INTERNET, (name=android.permission.WRITE_EXTERNAL_STORAGE;maxSdkVersion=18)
+
+# (list) features (adds uses-feature -tags to manifest)
+#android.features = android.hardware.usb.host
+
+# (int) Target Android API, should be as high as possible.
+#android.api = 31
+
+# (int) Minimum API your APK / AAB will support.
+#android.minapi = 21
+
+# (int) Android SDK version to use
+#android.sdk = 20
+
+# (str) Android NDK version to use
+#android.ndk = 23b
+
+# (int) Android NDK API to use. This is the minimum API your app will support, it should usually match android.minapi.
+#android.ndk_api = 21
+
+# (bool) Use --private data storage (True) or --dir public storage (False)
+#android.private_storage = True
+
+# (str) Android NDK directory (if empty, it will be automatically downloaded.)
+#android.ndk_path =
+
+# (str) Android SDK directory (if empty, it will be automatically downloaded.)
+#android.sdk_path =
+
+# (str) ANT directory (if empty, it will be automatically downloaded.)
+#android.ant_path =
+
+# (bool) If True, then skip trying to update the Android sdk
+# This can be useful to avoid excess Internet downloads or save time
+# when an update is due and you just want to test/build your package
+# android.skip_update = False
+
+# (bool) If True, then automatically accept SDK license
+# agreements. This is intended for automation only. If set to False,
+# the default, you will be shown the license when first running
+# buildozer.
+# android.accept_sdk_license = False
+
+# (str) Android entry point, default is ok for Kivy-based app
+#android.entrypoint = org.kivy.android.PythonActivity
+
+# (str) Full name including package path of the Java class that implements Android Activity
+# use that parameter together with android.entrypoint to set custom Java class instead of PythonActivity
+#android.activity_class_name = org.kivy.android.PythonActivity
+
+# (str) Extra xml to write directly inside the <manifest> element of AndroidManifest.xml
+# use that parameter to provide a filename from where to load your custom XML code
+#android.extra_manifest_xml = ./src/android/extra_manifest.xml
+
+# (str) Extra xml to write directly inside the <manifest><application> tag of AndroidManifest.xml
+# use that parameter to provide a filename from where to load your custom XML arguments:
+#android.extra_manifest_application_arguments = ./src/android/extra_manifest_application_arguments.xml
+
+# (str) Full name including package path of the Java class that implements Python Service
+# use that parameter to set custom Java class which extends PythonService
+#android.service_class_name = org.kivy.android.PythonService
+
+# (str) Android app theme, default is ok for Kivy-based app
+# android.apptheme = "@android:style/Theme.NoTitleBar"
+
+# (list) Pattern to whitelist for the whole project
+#android.whitelist =
+
+# (str) Path to a custom whitelist file
+#android.whitelist_src =
+
+# (str) Path to a custom blacklist file
+#android.blacklist_src =
+
+# (list) List of Java .jar files to add to the libs so that pyjnius can access
+# their classes. Don't add jars that you do not need, since extra jars can slow
+# down the build process. Allows wildcards matching, for example:
+# OUYA-ODK/libs/*.jar
+#android.add_jars = foo.jar,bar.jar,path/to/more/*.jar
+
+# (list) List of Java files to add to the android project (can be java or a
+# directory containing the files)
+#android.add_src =
+
+# (list) Android AAR archives to add
+#android.add_aars =
+
+# (list) Put these files or directories in the apk assets directory.
+# Either form may be used, and assets need not be in 'source.include_exts'.
+# 1) android.add_assets = source_asset_relative_path
+# 2) android.add_assets = source_asset_path:destination_asset_relative_path
+#android.add_assets =
+
+# (list) Put these files or directories in the apk res directory.
+# The option may be used in three ways, the value may contain one or zero ':'
+# Some examples:
+# 1) A file to add to resources, legal resource names contain ['a-z','0-9','_']
+# android.add_resources = my_icons/all-inclusive.png:drawable/all_inclusive.png
+# 2) A directory, here  'legal_icons' must contain resources of one kind
+# android.add_resources = legal_icons:drawable
+# 3) A directory, here 'legal_resources' must contain one or more directories, 
+# each of a resource kind:  drawable, xml, etc...
+# android.add_resources = legal_resources
+#android.add_resources =
+
+# (list) Gradle dependencies to add
+#android.gradle_dependencies =
+
+# (bool) Enable AndroidX support. Enable when 'android.gradle_dependencies'
+# contains an 'androidx' package, or any package from Kotlin source.
+# android.enable_androidx requires android.api >= 28
+#android.enable_androidx = True
+
+# (list) add java compile options
+# this can for example be necessary when importing certain java libraries using the 'android.gradle_dependencies' option
+# see https://developer.android.com/studio/write/java8-support for further information
+# android.add_compile_options = "sourceCompatibility = 1.8", "targetCompatibility = 1.8"
+
+# (list) Gradle repositories to add {can be necessary for some android.gradle_dependencies}
+# please enclose in double quotes 
+# e.g. android.gradle_repositories = "maven { url 'https://kotlin.bintray.com/ktor' }"
+#android.add_gradle_repositories =
+
+# (list) packaging options to add 
+# see https://google.github.io/android-gradle-dsl/current/com.android.build.gradle.internal.dsl.PackagingOptions.html
+# can be necessary to solve conflicts in gradle_dependencies
+# please enclose in double quotes 
+# e.g. android.add_packaging_options = "exclude 'META-INF/common.kotlin_module'", "exclude 'META-INF/*.kotlin_module'"
+#android.add_packaging_options =
+
+# (list) Java classes to add as activities to the manifest.
+#android.add_activities = com.example.ExampleActivity
+
+# (str) OUYA Console category. Should be one of GAME or APP
+# If you leave this blank, OUYA support will not be enabled
+#android.ouya.category = GAME
+
+# (str) Filename of OUYA Console icon. It must be a 732x412 png image.
+#android.ouya.icon.filename = %(source.dir)s/data/ouya_icon.png
+
+# (str) XML file to include as an intent filters in <activity> tag
+#android.manifest.intent_filters =
+
+# (list) Copy these files to src/main/res/xml/ (used for example with intent-filters)
+#android.res_xml = PATH_TO_FILE,
+
+# (str) launchMode to set for the main activity
+#android.manifest.launch_mode = standard
+
+# (str) screenOrientation to set for the main activity.
+# Valid values can be found at https://developer.android.com/guide/topics/manifest/activity-element
+#android.manifest.orientation = fullSensor
+
+# (list) Android additional libraries to copy into libs/armeabi
+#android.add_libs_armeabi = libs/android/*.so
+#android.add_libs_armeabi_v7a = libs/android-v7/*.so
+#android.add_libs_arm64_v8a = libs/android-v8/*.so
+#android.add_libs_x86 = libs/android-x86/*.so
+#android.add_libs_mips = libs/android-mips/*.so
+
+# (bool) Indicate whether the screen should stay on
+# Don't forget to add the WAKE_LOCK permission if you set this to True
+#android.wakelock = False
+
+# (list) Android application meta-data to set (key=value format)
+#android.meta_data =
+
+# (list) Android library project to add (will be added in the
+# project.properties automatically.)
+#android.library_references =
+
+# (list) Android shared libraries which will be added to AndroidManifest.xml using <uses-library> tag
+#android.uses_library =
+
+# (str) Android logcat filters to use
+#android.logcat_filters = *:S python:D
+
+# (bool) Android logcat only display log for activity's pid
+#android.logcat_pid_only = False
+
+# (str) Android additional adb arguments
+#android.adb_args = -H host.docker.internal
+
+# (bool) Copy library instead of making a libpymodules.so
+#android.copy_libs = 1
+
+# (list) The Android archs to build for, choices: armeabi-v7a, arm64-v8a, x86, x86_64
+# In past, was `android.arch` as we weren't supporting builds for multiple archs at the same time.
+android.archs = arm64-v8a, armeabi-v7a
+
+# (int) overrides automatic versionCode computation (used in build.gradle)
+# this is not the same as app version and should only be edited if you know what you're doing
+# android.numeric_version = 1
+
+# (bool) enables Android auto backup feature (Android API >=23)
+android.allow_backup = True
+
+# (str) XML file for custom backup rules (see official auto backup documentation)
+# android.backup_rules =
+
+# (str) If you need to insert variables into your AndroidManifest.xml file,
+# you can do so with the manifestPlaceholders property.
+# This property takes a map of key-value pairs. (via a string)
+# Usage example : android.manifest_placeholders = [myCustomUrl:\"org.kivy.customurl\"]
+# android.manifest_placeholders = [:]
+
+# (bool) Skip byte compile for .py files
+# android.no-byte-compile-python = False
+
+# (str) The format used to package the app for release mode (aab or apk or aar).
+# android.release_artifact = aab
+
+# (str) The format used to package the app for debug mode (apk or aar).
+# android.debug_artifact = apk
+
+#
+# Python for android (p4a) specific
+#
+
+# (str) python-for-android URL to use for checkout
+#p4a.url =
+
+# (str) python-for-android fork to use in case if p4a.url is not specified, defaults to upstream (kivy)
+#p4a.fork = kivy
+
+# (str) python-for-android branch to use, defaults to master
+#p4a.branch = master
+
+# (str) python-for-android specific commit to use, defaults to HEAD, must be within p4a.branch
+#p4a.commit = HEAD
+
+# (str) python-for-android git clone directory (if empty, it will be automatically cloned from github)
+#p4a.source_dir =
+
+# (str) The directory in which python-for-android should look for your own build recipes (if any)
+#p4a.local_recipes =
+
+# (str) Filename to the hook for p4a
+#p4a.hook =
+
+# (str) Bootstrap to use for android builds
+# p4a.bootstrap = sdl2
+
+# (int) port number to specify an explicit --port= p4a argument (eg for bootstrap flask)
+#p4a.port =
+
+# Control passing the --use-setup-py vs --ignore-setup-py to p4a
+# "in the future" --use-setup-py is going to be the default behaviour in p4a, right now it is not
+# Setting this to false will pass --ignore-setup-py, true will pass --use-setup-py
+# NOTE: this is general setuptools integration, having pyproject.toml is enough, no need to generate
+# setup.py if you're using Poetry, but you need to add "toml" to source.include_exts.
+#p4a.setup_py = false
+
+# (str) extra command line arguments to pass when invoking pythonforandroid.toolchain
+#p4a.extra_args =
+
+
+
+#
+# iOS specific
+#
+
+# (str) Path to a custom kivy-ios folder
+#ios.kivy_ios_dir = ../kivy-ios
+# Alternately, specify the URL and branch of a git checkout:
+ios.kivy_ios_url = https://github.com/kivy/kivy-ios
+ios.kivy_ios_branch = master
+
+# Another platform dependency: ios-deploy
+# Uncomment to use a custom checkout
+#ios.ios_deploy_dir = ../ios_deploy
+# Or specify URL and branch
+ios.ios_deploy_url = https://github.com/phonegap/ios-deploy
+ios.ios_deploy_branch = 1.10.0
+
+# (bool) Whether or not to sign the code
+ios.codesign.allowed = false
+
+# (str) Name of the certificate to use for signing the debug version
+# Get a list of available identities: buildozer ios list_identities
+#ios.codesign.debug = "iPhone Developer: <lastname> <firstname> (<hexstring>)"
+
+# (str) The development team to use for signing the debug version
+#ios.codesign.development_team.debug = <hexstring>
+
+# (str) Name of the certificate to use for signing the release version
+#ios.codesign.release = %(ios.codesign.debug)s
+
+# (str) The development team to use for signing the release version
+#ios.codesign.development_team.release = <hexstring>
+
+# (str) URL pointing to .ipa file to be installed
+# This option should be defined along with `display_image_url` and `full_size_image_url` options.
+#ios.manifest.app_url =
+
+# (str) URL pointing to an icon (57x57px) to be displayed during download
+# This option should be defined along with `app_url` and `full_size_image_url` options.
+#ios.manifest.display_image_url =
+
+# (str) URL pointing to a large icon (512x512px) to be used by iTunes
+# This option should be defined along with `app_url` and `display_image_url` options.
+#ios.manifest.full_size_image_url =
+
+
+[buildozer]
+
+# (int) Log level (0 = error only, 1 = info, 2 = debug (with command output))
+log_level = 2
+
+# (int) Display warning if buildozer is run as root (0 = False, 1 = True)
+warn_on_root = 1
+
+# (str) Path to build artifact storage, absolute or relative to spec file
+# build_dir = ./.buildozer
+
+# (str) Path to build output (i.e. .apk, .aab, .ipa) storage
+# bin_dir = ./bin
+
+#    -----------------------------------------------------------------------------
+#    List as sections
+#
+#    You can define all the "list" as [section:key].
+#    Each line will be considered as a option to the list.
+#    Let's take [app] / source.exclude_patterns.
+#    Instead of doing:
+#
+#[app]
+#source.exclude_patterns = license,data/audio/*.wav,data/images/original/*
+#
+#    This can be translated into:
+#
+#[app:source.exclude_patterns]
+#license
+#data/audio/*.wav
+#data/images/original/*
+#
+
+
+#    -----------------------------------------------------------------------------
+#    Profiles
+#
+#    You can extend section / key with a profile
+#    For example, you want to deploy a demo version of your application without
+#    HD content. You could first change the title to add "(demo)" in the name
+#    and extend the excluded directories to remove the HD content.
+#
+#[app@demo]
+#title = My Application (demo)
+#
+#[app:source.exclude_patterns@demo]
+#images/hd/*
+#
+#    Then, invoke the command line with the "demo" profile:
+#
+#buildozer --profile demo android debug

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,117 @@
+# distributed_executor.py
+import threading
+import queue
+import time
+import json
+from typing import Callable, Dict, List
+import socket
+from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
+import logging
+
+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={'load': str(load), 'node_id': self.local_node_id},
+            server=f"{name}.local."
+        )
+        self._zeroconf.register_service(service_info)
+    
+    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])
+                    self.peers.append({
+                        'ip': ip,
+                        'port': info.port,
+                        'load': float(info.properties[b'load']),
+                        'node_id': info.properties[b'node_id'].decode(),
+                        'last_seen': time.time()
+                    })
+        
+        listener = Listener()
+        browser = 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:
+            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._init_peer_discovery()
+        logging.basicConfig(level=logging.INFO)
+    
+    def _init_peer_discovery(self):
+        def discovery_loop():
+            while True:
+                self.available_peers = self.peer_registry.discover_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:
+            peer = min(self.available_peers, key=lambda x: x['load'])
+            self._send_to_peer(peer, task)
+        else:
+            logging.warning("لا توجد أجهزة متاحة - سيتم تنفيذ المهمة محلياً")
+    
+    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()
+            return response.json()
+        except Exception as e:
+            logging.error(f"فشل إرسال المهمة لـ {peer['node_id']}: {str(e)}")
+            return None
+
+# نموذج استخدام مبسط
+if __name__ == "__main__":
+    executor = DistributedExecutor("my_secret_key")
+    executor.peer_registry.register_service("node1", 7520, load=0.1)
+    print("نظام توزيع المهام جاهز...")

dts.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=Distributed Task System
+After=network.target
+
+[Service]
+ExecStart=/usr/local/bin/dts-start
+Restart=always
+User=root
+Group=root
+Environment=PATH=/usr/bin:/usr/local/bin
+Environment=PYTHONUNBUFFERED=1
+
+[Install]
+WantedBy=multi-user.target

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()

main.py

@@ -0,0 +1,80 @@
+# main.py
+import time
+import json
+from distributed_executor import DistributedExecutor
+from your_tasks import *
+# main.py
+from distributed_executor import DistributedExecutor
+import logging
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+    
+    try:
+        # تهيئة النظام
+        executor = DistributedExecutor("my_shared_secret_123")
+        executor.peer_registry.register_service("main_node", 7520)
+        
+        logging.info("نظام توزيع المهام يعمل...")
+        
+        # يمكنك هنا إضافة مهام للتنفيذ
+        while True:
+            time.sleep(1)
+            
+    except Exception as e:
+        logging.error(f"خطأ رئيسي: {str(e)}")
+
+if __name__ == "__main__":
+    main()
+def example_task(x):
+    # مهمة معقدة قابلة للتوزيع
+    return x * x + complex_operation(x)
+
+def benchmark(task_func, *args):
+    """قياس أداء المهمة"""
+    start = time.time()
+    result = task_func(*args)
+    duration = time.time() - start
+    return duration, result
+
+def main():
+    executor = DistributedExecutor("my_shared_secret_123")
+    executor.peer_registry.register_service("node1", 7520, load=0.2)
+
+    tasks = {
+        "1": ("ضرب المصفوفات", matrix_multiply, 500),
+        "2": ("حساب الأعداد الأولية", prime_calculation, 100000),
+        "3": ("معالجة البيانات", data_processing, 10000),
+        "4": ("محاكاة معالجة الصور", image_processing_emulation, 100),
+        "5": ("مهمة موزعة معقدة", example_task, 42)
+    }
+
+    while True:
+        print("\nنظام توزيع المهام الذكي")
+        print("اختر مهمة لتشغيلها:")
+        for k, v in tasks.items():
+            print(f"{k}: {v[0]}")
+        choice = input("اختر المهمة (أو 'q' للخروج): ")
+
+        if choice.lower() == 'q':
+            break
+
+        if choice in tasks:
+            name, func, arg = tasks[choice]
+            print(f"\nتشغيل: {name}...")
+
+            if choice == "5":
+                print("تم إرسال المهمة إلى العقدة الموزعة...")
+                future = executor.submit(func, arg)
+                result = future.result()
+                print(f"النتيجة (موزعة): {result}")
+            else:
+                duration, result = benchmark(func, arg)
+                print(f"النتيجة: {json.dumps(result, indent=2)[:200]}...")
+                print(f"الوقت المستغرق: {duration:.2f} ثانية")
+        else:
+            print("اختيار غير صحيح!")
+
+if __name__ == "__main__":
+    main()
+

main.spec

@@ -0,0 +1,38 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+
+a = Analysis(
+    ['main.py'],
+    pathex=[],
+    binaries=[],
+    datas=[],
+    hiddenimports=[],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name='main',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)

offload_debug.log

@@ -0,0 +1,15 @@
+2025-06-25 08:58:55,491 - INFO - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
+ * Running on all addresses (0.0.0.0)
+ * Running on http://127.0.0.1:7520
+ * Running on http://192.168.100.37:7520
+2025-06-25 08:58:55,492 - INFO - Press CTRL+C to quit
+2025-06-25 09:05:53,645 - INFO - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
+ * Running on all addresses (0.0.0.0)
+ * Running on http://127.0.0.1:7520
+ * Running on http://192.168.100.37:7520
+2025-06-25 09:05:53,647 - INFO - Press CTRL+C to quit
+2025-06-25 10:17:35,364 - INFO - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
+ * Running on all addresses (0.0.0.0)
+ * Running on http://127.0.0.1:7520
+ * Running on http://192.168.100.37:7520
+2025-06-25 10:17:35,365 - INFO - Press CTRL+C to quit

offload_lib.py

@@ -0,0 +1,140 @@
+# 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
+MIN_MEM = 500  # الحد الأدنى للذاكرة (MB)
+
+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}")
+
+def discover_peers(timeout=1.5):
+    """اكتشاف الأجهزة المتاحة على الشبكة"""
+    zc = Zeroconf()
+    listener = PeerListener()
+    ServiceBrowser(zc, "_http._tcp.local.", listener)
+    time.sleep(timeout)
+    zc.close()
+    return listener.peers
+
+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 or mem < MIN_MEM:
+            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 {"result": 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,127 @@
+import socket
+import time
+import requests
+from zeroconf import Zeroconf, ServiceBrowser
+from typing import List, Dict, Optional
+import urllib3
+import logging
+from dataclasses import dataclass
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+# إعداد التسجيل
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class Device:
+    name: str
+    ip: str
+    port: Optional[int] = None
+    device_type: str = "unknown"
+    last_seen: float = time.time()
+
+class NetworkDiscoverer:
+    def __init__(self):
+        self.local_devices: List[Device] = []
+        self.external_devices: List[Device] = []
+        self.central_server_urls = [
+            "https://89.111.171.92:1500/api/discover",
+            "https://backup-server.example.com:1500/api/discover"
+        ]
+    
+    def discover_all_devices(self, timeout: int = 3) -> Dict[str, List[Device]]:
+        """اكتشاف جميع الأجهزة (محلية وخارجية)"""
+        self._discover_local_devices(timeout)
+        self._discover_external_devices()
+        return {
+            "local": self.local_devices,
+            "external": self.external_devices
+        }
+    
+    def _discover_local_devices(self, timeout: int):
+        """اكتشاف الأجهزة على الشبكة المحلية"""
+        try:
+            zc = Zeroconf()
+            listener = self.LocalListener(self)
+            browser = ServiceBrowser(zc, "_tasknode._tcp.local.", listener)
+            time.sleep(timeout)
+            zc.close()
+        except Exception as e:
+            logger.error(f"فشل الاكتشاف المحلي: {e}")
+
+    def _discover_external_devices(self):
+        """اكتشاف الأجهزة عبر الخوادم المركزية"""
+        for server_url in self.central_server_urls:
+            try:
+                response = requests.get(server_url, timeout=5, verify=False)
+                if response.ok:
+                    self._process_external_devices(response.json())
+            except Exception as e:
+                logger.warning(f"فشل الاتصال بالخادم {server_url}: {e}")
+    
+    def _process_external_devices(self, devices_data):
+        """معالجة بيانات الأجهزة الخارجية"""
+        for device_data in devices_data.get('nodes', []):
+            if not self._is_duplicate_device(device_data):
+                device = Device(
+                    name=device_data.get('name', 'غير معروف'),
+                    ip=device_data.get('ip'),
+                    port=device_data.get('port'),
+                    device_type='external'
+                )
+                self.external_devices.append(device)
+
+    def _is_duplicate_device(self, device_data) -> bool:
+        """التحقق من عدم تكرار الجهاز"""
+        return any(
+            d.ip == device_data.get('ip') 
+            for d in self.local_devices + self.external_devices
+        )
+
+    class LocalListener:
+        def __init__(self, discoverer):
+            self.discoverer = discoverer
+        
+        def add_service(self, zc, type_, name):
+            self._process_service(zc, type_, name)
+        
+        def update_service(self, zc, type_, name):
+            self._process_service(zc, type_, name)
+        
+        def _process_service(self, zc, type_, name):
+            info = zc.get_service_info(type_, name)
+            if info and info.addresses:
+                ip = socket.inet_ntoa(info.addresses[0])
+                device = Device(
+                    name=name,
+                    ip=ip,
+                    port=info.port,
+                    device_type='local'
+                )
+                if not self.discoverer._is_duplicate_device(device.__dict__):
+                    self.discoverer.local_devices.append(device)
+
+def main():
+    discoverer = NetworkDiscoverer()
+    
+    while True:
+        try:
+            devices = discoverer.discover_all_devices()
+            
+            print("\n" + "="*40)
+            print(f"الأجهزة المحلية ({len(devices['local'])}):")  # تم تصحيح الأقواس هنا
+            for device in devices['local']:
+                print(f"- {device.name} ({device.ip}:{device.port})")
+            
+            print(f"\nالأجهزة الخارجية ({len(devices['external'])}):")  # و هنا
+            for device in devices['external']:
+                print(f"- {device.name} ({device.ip})")
+            
+            time.sleep(10)
+        except KeyboardInterrupt:
+            print("\nتم إيقاف الاكتشاف.")
+            break
+
+if __name__ == "__main__":
+    main()

peer_registry.py

@@ -0,0 +1,31 @@
+# peer_registry.py
+import socket
+import time
+from zeroconf import Zeroconf, ServiceBrowser
+
+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])
+            port = info.port
+            self.peers.append(f"{ip}:{port}")
+
+def discover_peers(timeout=2):
+    zc = Zeroconf()
+    listener = Listener()
+    ServiceBrowser(zc, "_http._tcp.local.", listener)
+    time.sleep(timeout)
+    zc.close()
+    return listener.peers
+
+# استخدام Zeroconf لاكتشاف الأقران
+zeroconf = Zeroconf()
+listener = Listener()
+browser = ServiceBrowser(zeroconf, "_taskdist._tcp.local.", listener)
+time.sleep(2)  # انتظار لاكتشاف الأقران
+available_peers = listener.peers  # ["192.168.1.2:7520", "10.0.0.5:7520"]
+

processor_manager.py

@@ -0,0 +1,47 @@
+# processor_manager.py
+import psutil
+from collections import deque
+
+cpu_load = psutil.cpu_percent(interval=1)  # نسبة استخدام CPU خلال ثانية
+mem_available = psutil.virtual_memory().available / (1024**2)  # الذاكرة المتاحة بالميجابايت
+
+if cpu_load > 70 or mem_available < 500:  # إذا تجاوز CPU 50% أو الذاكرة أقل من 500MB
+    trigger_offload()  # تشغيل عملية التوزيع
+
+class ResourceMonitor:
+    def __init__(self):
+        self.cpu_history = deque(maxlen=10)
+        self.mem_history = deque(maxlen=10)
+
+    def current_load(self):
+        # قياس الحمل الحالي
+        cpu = psutil.cpu_percent(interval=0.5) / 100.0
+        mem = psutil.virtual_memory().available / (1024**2)
+
+        # حفظ في التاريخ
+        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)
+
+        return {
+            "instant": {"cpu": cpu, "mem": mem},
+            "average": {"cpu": avg_cpu, "mem": avg_mem},
+            "recommendation": "offload" if avg_cpu > 0.7 or avg_mem < 500 else "local"
+        }
+
+def should_offload(task_complexity=0):
+    monitor = ResourceMonitor()
+    status = monitor.current_load()
+
+    # قرار التوزيع يعتمد على:
+    if (
+        status['average']['cpu'] > 0.6 or
+        status['average']['mem'] < 500 or
+        task_complexity > 75
+    ):
+        return True
+    return False
+

remote_executor.py

@@ -0,0 +1,21 @@
+# remote_executor.py
+import requests
+import os
+
+# استخدم عنوان السيرفر الخارجي من المتغير البيئي أو قيمة افتراضية
+REMOTE_SERVER = os.getenv("REMOTE_SERVER", "http://89.111.171.92:7520/run")
+
+def execute_remotely(func_name, args=[], kwargs={}):
+    try:
+        payload = {
+            "func": func_name,
+            "args": args,
+            "kwargs": kwargs
+        }
+        response = requests.post(REMOTE_SERVER, json=payload, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        return data.get("result", "⚠️ لا يوجد نتيجة")
+    except Exception as e:
+        return f"❌ فشل التنفيذ البعيد: {str(e)}"
+

requirements.txt

@@ -0,0 +1,5 @@
+flask
+requests
+psutil
+zeroconf
+flask_cors

rpc_server.py

@@ -0,0 +1,44 @@
+# rpc_server.py
+
+from flask import Flask, request, jsonify
+import smart_tasks  # ✅ غيّرنا من your_tasks إلى الاسم الحقيقي لملف المهام
+import logging
+
+# إعداد تسجيل الأحداث في ملف
+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:
+        data = request.get_json()
+        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,70 @@
+# 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
+import base64
+
+class SecurityManager:
+    def __init__(self, shared_secret: str):
+        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._peer_keys = {}
+    
+    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:
+        """توقيع المهمة رقميًا"""
+        signature = self._private_key.sign(
+            json.dumps(task).encode(),
+            padding.PSS(
+                mgf=padding.MGF1(hashes.SHA256()),
+                salt_length=padding.PSS.MAX_LENGTH
+            ),
+            hashes.SHA256()
+        )
+        return {**task, '_signature': base64.b64encode(signature).decode()}
+    
+    def verify_task(self, signed_task: Dict) -> bool:
+        """التحقق من صحة التوقيع"""
+        if '_signature' not in signed_task:
+            return False
+        
+        signature = base64.b64decode(signed_task['_signature'])
+        task_copy = {k: v for k, v in signed_task.items() if k != '_signature'}
+        
+        try:
+            self._peer_keys[signed_task['sender_id']].verify(
+                signature,
+                json.dumps(task_copy).encode(),
+                padding.PSS(
+                    mgf=padding.MGF1(hashes.SHA256()),
+                    salt_length=padding.PSS.MAX_LENGTH
+                ),
+                hashes.SHA256()
+            )
+            return True
+        except:
+            return False
+    
+    def _derive_key(self, password: str) -> bytes:
+        """اشتقاق مفتاح تشفير من كلمة المرور"""
+        salt = b'salt_placeholder'  # يجب تغييره في الإنتاج
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=salt,
+            iterations=100000
+        )
+        return base64.urlsafe_b64encode(kdf.derive(password.encode()))

server.py

@@ -0,0 +1,23 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from your_tasks import multiply_task  # دالة مربوطة بـ @offload
+
+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
+
+if __name__ == "__main__":
+    # هذا العنوان يسمح بالاستماع على IP خارجي لتلقي الاتصالات من الإنترنت
+    app.run(host="0.0.0.0", port=7520)
+
+

setup.py

@@ -0,0 +1,24 @@
+# setup.py
+from setuptools import setup, find_packages
+
+setup(
+    name="distributed-task-system",
+    version="1.0",
+    packages=find_packages(),
+    install_requires=[
+        "flask",
+        "requests",
+        "psutil",
+        "zeroconf",
+        "flask_cors",
+        "numpy"
+    ],
+    entry_points={
+        "console_scripts": [
+            "dts-start=dts_cli:main",
+        ],
+    },
+    data_files=[
+        ("/etc/systemd/system", ["dts.service"])
+    ]
+)

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}")
+

startup.py

@@ -0,0 +1,38 @@
+from autostart_config import AutoStartManager
+from distributed_executor import DistributedExecutor
+import logging
+import sys
+
+def main():
+    # إعداد السجل
+    logging.basicConfig(
+        filename='autostart.log',
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+    
+    try:
+        # تحميل الإعدادات
+        autostart = AutoStartManager()
+        if not autostart.config['enabled']:
+            logging.info("التشغيل التلقائي معطل في الإعدادات")
+            return
+        
+        # بدء النظام الرئيسي
+        logging.info("بدء تشغيل النظام الموزع تلقائياً")
+        executor = DistributedExecutor("my_shared_secret_123")
+        executor.peer_registry.register_service("auto_node", 7520)
+        
+        # هنا يمكنك إضافة أي مهام تريد تشغيلها تلقائياً
+        # executor.submit(...)
+        
+        # البقاء نشطاً
+        while True:
+            time.sleep(60)
+            
+    except Exception as e:
+        logging.error(f"خطأ في التشغيل التلقائي: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

task_interceptor.py

@@ -0,0 +1,9 @@
+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}"

your_tasks.py

@@ -0,0 +1,113 @@
+from offload_lib import offload
+import time
+import math
+import numpy as np
+from typing import Dict, List, Union
+
+# ============= وظائف مساعدة =============
+def _validate_positive_integer(value: int, name: str) -> None:
+    """تحقق من أن القيمة عدد صحيح موجب."""
+    if not isinstance(value, int) or value <= 0:
+        raise ValueError(f"{name} يجب أن يكون عددًا صحيحًا موجبًا")
+
+# ============= المهام الرئيسية =============
+@offload
+def matrix_multiply(size: int) -> Dict[str, List[List[float]]]:
+    """
+    ضرب مصفوفات كبير (عملية كثيفة الحساب)
+    
+    Args:
+        size: حجم المصفوفة (size x size)
+    
+    Returns:
+        نتيجة الضرب كقائمة ثنائية الأبعاد
+    """
+    _validate_positive_integer(size, "حجم المصفوفة")
+    
+    A = np.random.rand(size, size)
+    B = np.random.rand(size, size)
+    return {"result": np.dot(A, B).tolist()}
+
+@offload
+def prime_calculation(n: int) -> Dict[str, Union[int, List[int]]]:
+    """
+    حساب الأعداد الأولية حتى n
+    
+    Args:
+        n: الحد الأعلى للبحث عن الأعداد الأولية
+    
+    Returns:
+        قامة بالأعداد الأولية وعددها
+    """
+    _validate_positive_integer(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: int) -> Dict[str, int]:
+    """
+    محاكاة معالجة بيانات كبيرة
+    
+    Args:
+        data_size: عدد عناصر البيانات المراد معالجتها
+    
+    Returns:
+        عدد العناصر المعالجة
+    """
+    _validate_positive_integer(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: int) -> Dict[str, Union[int, float]]:
+    """
+    محاكاة معالجة الصور (عملية كثيفة الحساب)
+    
+    Args:
+        iterations: عدد التكرارات للمحاكاة
+    
+    Returns:
+        نتائج المحاكاة
+    """
+    _validate_positive_integer(iterations, "عدد التكرارات")
+    
+    results = []
+    for i in range(iterations):
+        value = sum(math.exp(math.sin(x)) for x in range(i, i+50))
+        results.append(value)
+    return {"iterations": iterations, "result": sum(results)}
+
+# ============= اختبار الوظائف محلياً =============
+if __name__ == "__main__":
+    # اختبار جميع الوظائف مع معالجة الأخطاء
+    test_cases = [
+        ("matrix_multiply", matrix_multiply, 100),
+        ("prime_calculation", prime_calculation, 1000),
+        ("data_processing", data_processing, 500),
+        ("image_processing", image_processing_emulation, 50)
+    ]
+    
+    for name, func, arg in test_cases:
+        try:
+            print(f"\nجارِ تشغيل: {name}...")
+            start = time.time()
+            result = func(arg)
+            duration = time.time() - start
+            
+            print(f"النتيجة: {str(result)[:200]}...")
+            print(f"الوقت المستغرق: {duration:.2f} ثانية")
+        except Exception as e:
+            print(f"فشل {name}: {str(e)}")