virsions and trnscript

TECHNICAL_DOCUMENTATION.md

@@ -0,0 +1,346 @@
+# نظام إدارة نسخ الفيديو المتقدم - التوثيق التقني
+
+## نظرة عامة
+نظام معالجة الفيديو المتكامل يوفر إدارة متقدمة للنسخ مع حماية النسخ الأصلية، ومعالجة منفصلة لكل نوع من التعديلات، وتتبع شامل لجميع الإصدارات.
+
+## المعمارية
+
+### المكونات الرئيسية
+
+#### 1. **نظام إدارة النسخ (VersionManager)**
+```python
+# الموقع: clipping/core/version_manager.py
+# الوظيفة: إدارة النسخ الأصلية والمعدلة مع الحفاظ على سلامة البيانات
+```
+
+**المميزات:**
+- حماية النسخ الأصلية في مجلد منفصل مع صلاحيات قراءة فقط
+- تتبع شجرة النسخ (parent-child relationships)
+- سجل تغييرات شامل
+- معرفات فريدة تلقائية
+- إحصائيات التخزين والاستخدام
+
+#### 2. **معالج الفيديو المتقدم (AdvancedVideoProcessor)**
+```python
+# الموقع: clipping/core/advanced_processor.py
+# الوظيفة: معالجة الفيديو باستخدام FFmpeg وMoviePy
+```
+
+**أنواع المعالجة:**
+- **ترانسكريبت**: إضافة نصوص مع الطوابع الزمنية
+- **قص**: قص مناطق محددة من الفيديو
+- **تأثيرات**: سطوع، تباين، تشبع، فلاتر جمالية
+- **صوت**: تعديل الصوت، تعزيز، إزالة ضوضاء
+- **مشترك**: معالجة متعددة في خطوة واحدة
+
+#### 3. **واجهة برمجة التطبيقات (API)**
+```python
+# الموقع: clipping/routers/video_versions.py
+# الوظيفة: نقاط النهاية REST للتفاعل مع النظام
+```
+
+## نقاط النهاية API
+
+### رفع الفيديو الأصلي
+```http
+POST /api/v1/video-versions/upload-original
+Content-Type: multipart/form-data
+
+Body:
+- video_file: ملف الفيديو (مطلوب)
+- metadata: بيانات وصفية اختيارية (JSON)
+```
+
+**الاستجابة:**
+```json
+{
+  "original_id": "uuid-string",
+  "file_name": "video.mp4",
+  "file_size": 10485760,
+  "upload_date": "2024-01-15T10:30:00Z",
+  "message": "Original video uploaded successfully",
+  "status": "protected"
+}
+```
+
+### معالجة الترانسكريبت
+```http
+POST /api/v1/video-versions/{original_id}/add-transcript
+Content-Type: multipart/form-data
+
+Body:
+- transcript_config: إعدادات الترانسكريبت (JSON مطلوب)
+- version_name: اسم النسخة الاختياري
+```
+
+**مثال transcript_config:**
+```json
+{
+  "segments": [
+    {
+      "start": 0.0,
+      "end": 5.0,
+      "text": "مرحباً بكم في الفيديو",
+      "position": "bottom",
+      "font_size": 28,
+      "font_color": "#FFFFFF"
+    }
+  ],
+  "font_size": 24,
+  "font_color": "#FFFFFF",
+  "font_family": "Arial",
+  "position": "bottom",
+  "background_color": "#000000",
+  "background_alpha": 0.8,
+  "margin": 20,
+  "shadow": true,
+  "outline": true
+}
+```
+
+### معالجة القص
+```http
+POST /api/v1/video-versions/{original_id}/crop
+Content-Type: multipart/form-data
+
+Body:
+- crop_config: إعدادات القص (JSON مطلوب)
+- version_name: اسم النسخة الاختياري
+```
+
+**مثال crop_config:**
+```json
+{
+  "x1": 100,
+  "y1": 50,
+  "width": 800,
+  "height": 600,
+  "center_crop": false,
+  "aspect_ratio": "16:9"
+}
+```
+
+### معالجة التأثيرات
+```http
+POST /api/v1/video-versions/{original_id}/effects
+Content-Type: multipart/form-data
+
+Body:
+- effects_config: إعدادات التأثيرات (JSON مطلوب)
+- version_name: اسم النسخة الاختياري
+```
+
+**مثال effects_config:**
+```json
+{
+  "brightness": 1.2,
+  "contrast": 1.1,
+  "saturation": 1.3,
+  "fade_in": 2.0,
+  "fade_out": 3.0,
+  "blur": 0.5,
+  "vignette": 0.3,
+  "vintage": true
+}
+```
+
+### معالجة الصوت
+```http
+POST /api/v1/video-versions/{original_id}/audio
+Content-Type: multipart/form-data
+
+Body:
+- audio_config: إعدادات الصوت (JSON مطلوب)
+- version_name: اسم النسخة الاختياري
+```
+
+**مثال audio_config:**
+```json
+{
+  "volume": 1.5,
+  "normalize": true,
+  "remove_noise": true,
+  "bass_boost": 0.3,
+  "fade_in": 1.0,
+  "fade_out": 2.0,
+  "speed": 1.1
+}
+```
+
+### معالجة مشتركة
+```http
+POST /api/v1/video-versions/{original_id}/combined
+Content-Type: multipart/form-data
+
+Body:
+- processing_request: طلب المعالجة المشتركة (JSON مطلوب)
+- version_name: اسم النسخة الاختياري
+```
+
+**مثال processing_request:**
+```json
+{
+  "original_id": "uuid-string",
+  "processing_type": "combined",
+  "transcript_config": { /* نفس إعدادات الترانسكريبت */ },
+  "crop_config": { /* نفس إعدادات القص */ },
+  "effects_config": { /* نفس إعدادات التأثيرات */ },
+  "audio_config": { /* نفس إعدادات الصوت */ },
+  "priority": "high",
+  "metadata": {}
+}
+```
+
+### إدارة النسخ
+
+#### قائمة النسخ
+```http
+GET /api/v1/video-versions/versions/{original_id}
+```
+
+#### تفاصيل نسخة
+```http
+GET /api/v1/video-versions/version/{version_id}
+```
+
+#### تحميل نسخة
+```http
+GET /api/v1/video-versions/download/{version_id}
+```
+
+#### حذف نسخة
+```http
+DELETE /api/v1/video-versions/delete/{version_id}
+```
+
+#### شجرة النسخ
+```http
+GET /api/v1/video-versions/version-tree/{original_id}
+```
+
+### إحصائيات النظام
+```http
+GET /api/v1/video-versions/stats
+```
+
+## معايير الأداء
+
+### الجودة
+- **الأصلي**: يتم الحفاظ على جودة الفيديو الأصلي بدون أي تعديلات
+- **المعالجة**: استخدام FFmpeg لضمان أعلى جودة ممكنة
+- **الترميز**: H.264 مع إعدادات مثالية للحفاظ على الجودة
+
+### السرعة
+- **الرفع**: معالجة غير متزامنة مع مؤشرات تقدم
+- **المعالجة**: معالجة متعددة الخيوط مع ThreadPoolExecutor
+- **الذاكرة**: إدارة مثالية للذاكرة مع تنظيف تلقائي
+
+### الموثوقية
+- **الأخطاء**: معالجة شاملة للأخطاء مع استعادة تلقائية
+- **السجل**: سجل تفصيلي لجميع العمليات
+- **النسخ الاحتياطي**: آلية نسخ احتياطي للنسخ الأصلية
+
+## هيكل الملفات
+
+```
+video_storage/
+├── originals/          # النسخ الأصلية (قراءة فقط)
+│   └── {original_id}/
+│       └── {file_name}
+├── versions/           # النسخ المعدلة
+│   └── {version_id}/
+│       ├── video.mp4   # الفيديو المعدل
+│       ├── config.json # إعدادات المعالجة
+│       └── metadata.json # البيانات الوصفية
+└── version_registry.json # سجل جميع النسخ
+```
+
+## أمثلة الاستخدام
+
+### مثال 1: رفع فيديو وإضافة ترانسكريبت
+```python
+import requests
+
+# رفع الفيديو الأصلي
+files = {'video_file': open('video.mp4', 'rb')}
+response = requests.post('http://localhost:7860/api/v1/video-versions/upload-original', files=files)
+original_id = response.json()['original_id']
+
+# إعدادات الترانسكريبت
+transcript_config = {
+    "segments": [
+        {"start": 0, "end": 5, "text": "مرحباً بكم"},
+        {"start": 5, "end": 10, "text": "هذا فيديو تجريبي"}
+    ],
+    "font_size": 24,
+    "font_color": "#FFFFFF",
+    "position": "bottom"
+}
+
+# إضافة الترانسكريبت
+data = {'transcript_config': str(transcript_config).replace("'", '"')}
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/add-transcript', data=data)
+version_id = response.json()['version_id']
+```
+
+### مثال 2: قص فيديو مع تأثيرات
+```python
+# إعدادات القص
+crop_config = {
+    "center_crop": True,
+    "width": 720,
+    "height": 1280,  # 9:16 aspect ratio
+    "aspect_ratio": "9:16"
+}
+
+# إعدادات التأثيرات
+effects_config = {
+    "brightness": 1.2,
+    "contrast": 1.1,
+    "saturation": 1.3,
+    "vintage": True
+}
+
+# معالجة القص
+data = {'crop_config': str(crop_config).replace("'", '"')}
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/crop', data=data)
+crop_version_id = response.json()['version_id']
+
+# معالجة التأثيرات على النسخة المقصوصة
+data = {'effects_config': str(effects_config).replace("'", '"')}
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{crop_version_id}/effects', data=data)
+final_version_id = response.json()['version_id']
+```
+
+## معالجة الأخطاء
+
+### رموز الحالة
+- **200**: نجاح
+- **400**: طلب غير صالح
+- **404**: مورد غير موجود
+- **422**: بيانات غير صالحة
+- **500**: خطأ في الخادم
+
+### رسائل الخطأ
+```json
+{
+  "error": "Invalid processing configuration",
+  "details": "Font size must be between 12 and 72",
+  "suggestion": "Please adjust font_size parameter"
+}
+```
+
+## التحسينات المستقبلية
+
+1. **معالجة GPU**: دعم معالجة GPU لتسريع العمليات
+2. **تخزين سحابي**: دعم تخزين Amazon S3 وGoogle Cloud Storage
+3. **ذكاء اصطناعي**: إضافة تأثيرات AI مثل إزالة الخلفية
+4. **تعاوني**: دعم العمل الجماعي والتعليقات
+5. **تكامل API**: REST API كامل مع Swagger documentation
+
+## التواصل والدعم
+
+للأسئلة والدعم الفني، يرجى التواصل عبر:
+- البريد ا��إلكتروني: support@videosystem.com
+- GitHub Issues: github.com/videosystem/issues
+- الوثائق الكاملة: docs.videosystem.com

USER_GUIDE.md

@@ -0,0 +1,720 @@
+# دليل استخدام نظام إدارة نسخ الفيديو المتقدم
+
+## 📋 جدول المحتويات
+1. [مقدمة](#مقدمة)
+2. [التثبيت والإعداد](#التثبيت-والإعداد)
+3. [رفع الفيديو الأصلي](#رفع-الفيديو-الأصلي)
+4. [إضافة ترانسكريبت](#إضافة-ترانسكريبت)
+5. [قص الفيديو](#قص-الفيديو)
+6. [إضافة تأثيرات](#إضافة-تأثيرات)
+7. [معالجة الصوت](#معالجة-الصوت)
+8. [المعالجة المشتركة](#المعالجة-المشتركة)
+9. [إدارة النسخ](#إدارة-النسخ)
+10. [أمثلة عملية](#أمثلة-عملية)
+11. [نصائح وتوصيات](#نصائح-وأفضل-الممارسات)
+12. [استكشاف الأخطاء](#استكشاف-الأخطاء)
+
+## 🎯 مقدمة
+
+نظام إدارة نسخ الفيديو المتقدم هو حل شامل لمعالجة الفيديو مع الحفاظ على النسخ الأصلية. يتيح لك إنشاء نسخ متعددة من نفس الفيديو مع تعديلات مختلفة مع الحفاظ على النسخة الأصلية دون أي تغيير.
+
+### المميزات الرئيسية:
+- ✅ حماية النسخ الأصلية (قراءة فقط)
+- ✅ إنشاء نسخ متعددة من نفس الفيديو
+- ✅ معالجة منفصلة لكل نوع من التعديلات
+- ✅ تتبع شامل لجميع الإصدارات
+- ✅ واجهة برمجة تطبيقات REST سهلة الاستخدام
+- ✅ معالجة غير متزامنة لتحسين الأداء
+
+## ⚙️ التثبيت والإعداد
+
+### المتطلبات الأساسية
+```bash
+# Python 3.8 أو أحدث
+python --version
+
+# تثبيت المتطلبات
+pip install fastapi uvicorn python-multipart moviepy ffmpeg-python pydantic
+```
+
+### تشغيل الخادم
+```bash
+# من المجلد الرئيسي
+python main.py
+
+# أو باستخدام uvicorn مباشرة
+uvicorn main:app --host 0.0.0.0 --port 7860 --reload
+```
+
+### التحقق من التشغيل
+افتح المتصفح وانتقل إلى:
+```
+http://localhost:7860/
+```
+
+يجب أن ترى رسالة ترحيب مع معلومات النظام.
+
+## 📤 رفع الفيديو الأصلي
+
+### الخطوة 1: رفع الفيديو
+```python
+import requests
+
+# رفع الفيديو الأصلي
+files = {'video_file': open('video.mp4', 'rb')}
+response = requests.post('http://localhost:7860/api/v1/video-versions/upload-original', files=files)
+
+# استخراج معرف الفيديو الأصلي
+original_id = response.json()['original_id']
+print(f"Original ID: {original_id}")
+```
+
+### الخطوة 2: التحقق من الرفع
+```python
+# التحقق من معلومات الفيديو الأصلي
+response = requests.get(f'http://localhost:7860/api/v1/video-versions/versions/{original_id}')
+print(response.json())
+```
+
+## 📝 إضافة ترانسكريبت
+
+### مثال 1: ترانسكريبت بسيط
+```python
+# إعدادات الترانسكريبت
+transcript_config = {
+    "segments": [
+        {
+            "start": 0.0,
+            "end": 5.0,
+            "text": "مرحباً بكم في الفيديو",
+            "position": "bottom"
+        },
+        {
+            "start": 5.0,
+            "end": 10.0,
+            "text": "سنشرح لكم كيفية استخدام النظام",
+            "position": "bottom"
+        }
+    ],
+    "font_size": 24,
+    "font_color": "#FFFFFF",
+    "font_family": "Arial",
+    "position": "bottom",
+    "background_color": "#000000",
+    "background_alpha": 0.8,
+    "margin": 20,
+    "shadow": True,
+    "outline": True
+}
+
+# إرسال طلب الترانسكريبت
+data = {
+    "transcript_config": json.dumps(transcript_config, ensure_ascii=False),
+    "version_name": "version_with_transcript"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/add-transcript', data=data)
+version_id = response.json()['version_id']
+print(f"Transcript Version ID: {version_id}")
+```
+
+### مثال 2: ترانسكريبت متقدم مع أنيميشن
+```python
+# ترانسكريبت مع أنيميشن
+transcript_config = {
+    "segments": [
+        {
+            "start": 0.0,
+            "end": 3.0,
+            "text": "اهلاً وسهلاً",
+            "position": "center",
+            "font_size": 32,
+            "font_color": "#FFD700"  # لون ذهبي
+        },
+        {
+            "start": 3.0,
+            "end": 8.0,
+            "text": "هذا عرض تقديمي احترافي",
+            "position": "bottom",
+            "font_size": 28,
+            "font_color": "#FFFFFF"
+        }
+    ],
+    "font_size": 24,
+    "font_color": "#FFFFFF",
+    "font_family": "Helvetica",
+    "position": "bottom",
+    "background_color": "#1E3A8A",
+    "background_alpha": 0.9,
+    "margin": 30,
+    "opacity": 1.0,
+    "animation": "fade_in",
+    "shadow": True,
+    "outline": True
+}
+
+# إرسال الطلب
+data = {
+    "transcript_config": json.dumps(transcript_config, ensure_ascii=False),
+    "version_name": "animated_transcript_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/add-transcript', data=data)
+```
+
+## ✂️ قص الفيديو
+
+### مثال 1: قص منطقة محددة
+```python
+# إعدادات القص
+crop_config = {
+    "x1": 200,        # بداية من اليسار
+    "y1": 100,        # بداية من الأعلى
+    "width": 800,     # عرض المنطقة
+    "height": 600,    # ارتفاع المنطقة
+    "center_crop": False
+}
+
+# إرسال طلب القص
+data = {
+    "crop_config": json.dumps(crop_config),
+    "version_name": "cropped_region_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/crop', data=data)
+crop_version_id = response.json()['version_id']
+```
+
+### مثال 2: قص تلقائي من المركز
+```python
+# قص من المركز لإنشاء فيديو عمودي (Shorts)
+crop_config = {
+    "center_crop": True,
+    "width": 720,     # عرض Shorts
+    "height": 1280,   # ارتفاع Shorts (9:16)
+    "aspect_ratio": "9:16"
+}
+
+# إرسال الطلب
+data = {
+    "crop_config": json.dumps(crop_config),
+    "version_name": "shorts_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/crop', data=data)
+shorts_version_id = response.json()['version_id']
+```
+
+### مثال 3: قص لإنشاء فيديو مربع
+```python
+# قص لإنشاء فيديو مربع للإنستغرام
+crop_config = {
+    "center_crop": True,
+    "width": 1080,    # عرض مربع
+    "height": 1080,   # ارتفاع مربع (1:1)
+    "aspect_ratio": "1:1"
+}
+
+# إرسال الطلب
+data = {
+    "crop_config": json.dumps(crop_config),
+    "version_name": "instagram_square_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/crop', data=data)
+instagram_version_id = response.json()['version_id']
+```
+
+## 🎨 إضافة تأثيرات
+
+### مثال 1: تأثيرات أساسية
+```python
+# إعدادات التأثيرات الأساسية
+effects_config = {
+    "brightness": 1.2,      # سطوع +20%
+    "contrast": 1.1,        # تباين +10%
+    "saturation": 1.3,      # تشبع +30%
+    "fade_in": 2.0,         # تلاشي دخول 2 ثانية
+    "fade_out": 3.0         # تلاشي خروج 3 ثواني
+}
+
+# إرسال الطلب
+data = {
+    "effects_config": json.dumps(effects_config),
+    "version_name": "enhanced_effects_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/effects', data=data)
+effects_version_id = response.json()['version_id']
+```
+
+### مثال 2: تأثيرات فنية
+```python
+# تأثيرات فنية (فينتاج)
+effects_config = {
+    "sepia": True,          # تأثير سيبيا (بني قديم)
+    "vintage": True,        # تأثير فينتاج
+    "vignette": 0.4,        # تأثير إطار مظلم
+    "noise": 0.1,           # ضوضاء خفيفة
+    "blur": 0.2             # ضبابية خفيفة
+}
+
+# إرسال الطلب
+data = {
+    "effects_config": json.dumps(effects_config),
+    "version_name": "vintage_artistic_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/effects', data=data)
+vintage_version_id = response.json()['version_id']
+```
+
+### مثال 3: تأثيرات درامية
+```python
+# تأثيرات درامية
+effects_config = {
+    "black_white": True,    # أبيض وأسود
+    "contrast": 1.5,        # تباين عالي
+    "sharpen": 2.0,         # حدة عالية
+    "fade_in": 1.0,         # تلاشي سريع
+    "fade_out": 2.0         # تلاشي بطيء
+}
+
+# إرسال الطلب
+data = {
+    "effects_config": json.dumps(effects_config),
+    "version_name": "dramatic_black_white_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/effects', data=data)
+dramatic_version_id = response.json()['version_id']
+```
+
+## 🔊 معالجة الصوت
+
+### مثال 1: تعزيز الصوت الأساسي
+```python
+# إعدادات الصوت الأساسية
+audio_config = {
+    "volume": 1.3,          # رفع الصوت 30%
+    "normalize": True,      # تطبيع الصوت
+    "remove_noise": True,   # إزالة الضوضاء
+    "fade_in": 1.0,         # تلاشي دخول
+    "fade_out": 2.0         # تلاشي خروج
+}
+
+# إرسال الطلب
+data = {
+    "audio_config": json.dumps(audio_config),
+    "version_name": "enhanced_audio_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/audio', data=data)
+audio_version_id = response.json()['version_id']
+```
+
+### مثال 2: تأثيرات صوتية
+```python
+# تأثيرات صوتية متقدمة
+audio_config = {
+    "bass_boost": 0.5,      # تعزيز الجهير
+    "treble_boost": 0.3,    # تعزيز التريبل
+    "speed": 1.1,           # تسريع 10% (بدون تغيير النبرة)
+    "pitch_shift": 2,       # رفع النبرة 2 نصف نغمة
+    "fade_in": 0.5,         # تلاشي سريع
+    "fade_out": 1.0         # تلاشي متوسط
+}
+
+# إرسال الطلب
+data = {
+    "audio_config": json.dumps(audio_config),
+    "version_name": "processed_audio_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/audio', data=data)
+processed_audio_version_id = response.json()['version_id']
+```
+
+## 🔄 المعالجة المشتركة
+
+### مثال: إنشاء فيديو Shorts احترافي
+```python
+# معالجة مشتركة متكاملة
+processing_request = {
+    "original_id": original_id,
+    "processing_type": "combined",
+    "transcript_config": {
+        "segments": [
+            {
+                "start": 0.0,
+                "end": 5.0,
+                "text": "نصيحة ذهبية للنجاح",
+                "position": "center",
+                "font_size": 28,
+                "font_color": "#FFD700"
+            }
+        ],
+        "font_size": 24,
+        "font_color": "#FFFFFF",
+        "position": "bottom",
+        "shadow": True,
+        "outline": True
+    },
+    "crop_config": {
+        "center_crop": True,
+        "width": 720,
+        "height": 1280,
+        "aspect_ratio": "9:16"
+    },
+    "effects_config": {
+        "brightness": 1.1,
+        "contrast": 1.2,
+        "saturation": 1.1,
+        "fade_in": 1.0,
+        "vintage": False
+    },
+    "audio_config": {
+        "volume": 1.2,
+        "normalize": True,
+        "remove_noise": True,
+        "fade_in": 0.5,
+        "fade_out": 1.0
+    },
+    "priority": "high",
+    "metadata": {
+        "description": "Shorts video with transcript, crop, effects and audio enhancement",
+        "target_platform": "YouTube Shorts"
+    }
+}
+
+# إرسال الطلب المشترك
+data = {
+    "processing_request": json.dumps(processing_request, ensure_ascii=False),
+    "version_name": "professional_shorts_version"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/combined', data=data)
+combined_version_id = response.json()['version_id']
+```
+
+## 📋 إدارة النسخ
+
+### عرض جميع النسخ
+```python
+# الحصول على قائمة جميع النسخ
+response = requests.get(f'http://localhost:7860/api/v1/video-versions/versions/{original_id}')
+versions_info = response.json()
+
+print(f"عدد النسخ: {versions_info['total_count']}")
+for version in versions_info['versions']:
+    print(f"- {version['version_name']}: {version['processing_type']} ({version['status']})")
+```
+
+### عرض تفاصيل نسخة محددة
+```python
+# الحصول على تفاصيل نسخة محددة
+version_id = "your-version-id"  # استبدل بمعرف النسخة
+response = requests.get(f'http://localhost:7860/api/v1/video-versions/version/{version_id}')
+version_details = response.json()
+
+print(f"اسم النسخة: {version_details['version_name']}")
+print(f"نوع المعالجة: {version_details['processing_type']}")
+print(f"الحالة: {version_details['status']}")
+print(f"تاريخ الإنشاء: {version_details['created_at']}")
+print(f"حجم الملف: {version_details['file_size']} بايت")
+print(f"المدة: {version_details['duration']} ثانية")
+print(f"الدقة: {version_details['resolution']}")
+```
+
+### تحميل نسخة
+```python
+# تحميل نسخة معالجة
+response = requests.get(f'http://localhost:7860/api/v1/video-versions/download/{version_id}')
+
+# حفظ الملف
+with open('downloaded_video.mp4', 'wb') as f:
+    f.write(response.content)
+
+print("تم تحميل النسخة بنجاح!")
+```
+
+### حذف نسخة
+```python
+# حذف نسخة غير مرغوب فيها
+response = requests.delete(f'http://localhost:7860/api/v1/video-versions/delete/{version_id}')
+delete_result = response.json()
+
+print(f"تم حذف النسخة: {delete_result['version_id']}")
+```
+
+### عرض شجرة النسخ
+```python
+# عرض العلاقات بين النسخ المختلفة
+response = requests.get(f'http://localhost:7860/api/v1/video-versions/version-tree/{original_id}')
+tree_info = response.json()
+
+print("شجرة النسخ:")
+print(json.dumps(tree_info['version_tree'], indent=2, ensure_ascii=False))
+```
+
+### عرض إحصائيات النظام
+```python
+# عرض إحصائيات التخزين والاستخدام
+response = requests.get('http://localhost:7860/api/v1/video-versions/stats')
+stats = response.json()
+
+print(f"عدد الفيديوهات الأصلية: {stats['storage']['original_videos']}")
+print(f"عدد النسخ المعدلة: {stats['storage']['total_versions']}")
+print(f"حجم الفيديوهات الأصلية: {stats['storage']['originals_size']} بايت")
+print(f"حجم النسخ المعدلة: {stats['storage']['versions_size']} بايت")
+print(f"الحجم الكلي: {stats['storage']['total_size']} بايت")
+print(f"حالة النظام: {stats['system_status']}")
+```
+
+## 💡 أمثلة عملية
+
+### مثال 1: إنشاء فيديو تعليمي مع ترانسكريبت
+```python
+import requests
+import json
+
+# 1. رفع الفيديو الأصلي
+files = {'video_file': open('educational_video.mp4', 'rb')}
+response = requests.post('http://localhost:7860/api/v1/video-versions/upload-original', files=files)
+original_id = response.json()['original_id']
+
+# 2. إضافة ترانسكريبت تعليمي
+transcript_config = {
+    "segments": [
+        {"start": 0, "end": 8, "text": "مرحباً بكم في هذا الدرس التعليمي"},
+        {"start": 8, "end": 20, "text": "اليوم سنتعلم كيفية استخدام Python في معالجة البيانات"},
+        {"start": 20, "end": 35, "text": "Python هو لغة برمجة قوية وسهلة التعلم"}
+    ],
+    "font_size": 26,
+    "font_color": "#2E86AB",
+    "font_family": "Arial",
+    "position": "bottom",
+    "background_color": "#F5F5F5",
+    "background_alpha": 0.9,
+    "margin": 25,
+    "shadow": True,
+    "outline": False
+}
+
+data = {
+    "transcript_config": json.dumps(transcript_config, ensure_ascii=False),
+    "version_name": "educational_with_transcript"
+}
+
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/add-transcript', data=data)
+educational_version_id = response.json()['version_id']
+
+print(f"تم إنشاء نسخة تعليمية مع ترانسكريبت: {educational_version_id}")
+```
+
+### مثال 2: إنشاء فيديو تسويقي للسوشيال ميديا
+```python
+# 1. نبدأ من نفس الفيديو الأصلي
+
+# 2. إنشاء نسخة عمودية مع تأثيرات
+crop_config = {
+    "center_crop": True,
+    "width": 720,
+    "height": 1280,
+    "aspect_ratio": "9:16"
+}
+
+effects_config = {
+    "brightness": 1.15,
+    "contrast": 1.2,
+    "saturation": 1.25,
+    "fade_in": 1.5,
+    "fade_out": 2.0,
+    "vignette": 0.2
+}
+
+audio_config = {
+    "volume": 1.3,
+    "normalize": True,
+    "bass_boost": 0.4,
+    "fade_in": 0.8,
+    "fade_out": 1.5
+}
+
+# إنشاء النسخة المقصوصة أولاً
+data = {
+    "crop_config": json.dumps(crop_config),
+    "version_name": "social_media_cropped"
+}
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/crop', data=data)
+cropped_version_id = response.json()['version_id']
+
+# ثم نضيف التأثيرات على النسخة المقصوصة
+data = {
+    "effects_config": json.dumps(effects_config),
+    "version_name": "social_media_final"
+}
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{cropped_version_id}/effects', data=data)
+final_version_id = response.json()['version_id']
+
+# أخيراً نعالج الصوت
+data = {
+    "audio_config": json.dumps(audio_config),
+    "version_name": "social_media_complete"
+}
+response = requests.post(f'http://localhost:7860/api/v1/video-versions/{final_version_id}/audio', data=data)
+complete_version_id = response.json()['version_id']
+
+print(f"تم إنشاء فيديو تسويقي متكامل: {complete_version_id}")
+```
+
+### مثال 3: معالجة دفعية لعدة فيديوهات
+```python
+def process_video_batch(video_files, processing_config):
+    """معالجة دفعية لعدة فيديوهات"""
+    results = []
+    
+    for video_file in video_files:
+        try:
+            # رفع الفيديو
+            files = {'video_file': open(video_file, 'rb')}
+            response = requests.post('http://localhost:7860/api/v1/video-versions/upload-original', files=files)
+            original_id = response.json()['original_id']
+            
+            # تطبيق نفس المعالجة على جميع الفيديوهات
+            data = {
+                "processing_request": json.dumps(processing_config),
+                "version_name": f"processed_{Path(video_file).stem}"
+            }
+            
+            response = requests.post(f'http://localhost:7860/api/v1/video-versions/{original_id}/combined', data=data)
+            version_id = response.json()['version_id']
+            
+            results.append({
+                'original_file': video_file,
+                'original_id': original_id,
+                'version_id': version_id,
+                'status': 'success'
+            })
+            
+        except Exception as e:
+            results.append({
+                'original_file': video_file,
+                'error': str(e),
+                'status': 'failed'
+            })
+    
+    return results
+
+# إعدادات المعالجة الموحدة
+processing_config = {
+    "original_id": "placeholder",  # سيتم استب��اله لكل فيديو
+    "processing_type": "combined",
+    "transcript_config": {
+        "segments": [{"start": 0, "end": 5, "text": "شاهد هذا الفيديو المميز"}],
+        "font_size": 28,
+        "font_color": "#FF6B35",
+        "position": "center"
+    },
+    "crop_config": {
+        "center_crop": True,
+        "width": 720,
+        "height": 1280,
+        "aspect_ratio": "9:16"
+    },
+    "effects_config": {
+        "brightness": 1.1,
+        "contrast": 1.1,
+        "fade_in": 1.0
+    },
+    "audio_config": {
+        "volume": 1.2,
+        "normalize": True
+    },
+    "priority": "normal"
+}
+
+# قائمة الفيديوهات للمعالجة
+video_files = ['video1.mp4', 'video2.mp4', 'video3.mp4']
+
+# تنفيذ المعالجة الدفعية
+results = process_video_batch(video_files, processing_config)
+
+# عرض النتائج
+for result in results:
+    if result['status'] == 'success':
+        print(f"✅ {result['original_file']} -> {result['version_id']}")
+    else:
+        print(f"❌ {result['original_file']} -> خطأ: {result['error']}")
+```
+
+## 🎯 نصائح وأفضل الممارسات
+
+### 1. اختيار الإعدادات المناسبة
+- **الترانسكريبت**: استخدم أحجام خط مناسبة (20-32) حسب حجم الفيديو
+- **القص**: احتفظ بنسب الأبعاد المناسبة لكل منصة (9:16 للـ Shorts، 1:1 للإنستغرام)
+- **التأثيرات**: لا تبالغ في التأثيرات، ابدأ بقيم صغيرة وزد تدريجياً
+- **الصوت**: استخدم تطبيع الصوت دائماً لضمان جودة متسقة
+
+### 2. إدارة النسخ بكفاءة
+- أطلق على النسخ أسماء واضحة ومعبرة
+- احذف النسخ غير المستخدمة لتوفير المساحة
+- استخدم شجرة النسخ لفهم العلاقات بين النسخ
+- احتفظ بالنسخ الأصلية دائماً كنسخة احتياطية
+
+### 3. تحسين الأداء
+- استخدم المعالجة المشتركة لتقليل عدد خطوات المعالجة
+- حدد أولوية المعالجة حسب أهمية الفيديو
+- راقب إحصائيات النظام لتجنب تجاوز الحدود
+- استخدم معالجة غير متزامنة للفيديوهات الكبيرة
+
+### 4. ضمان الجودة
+- اختبر الإعدادات على نسخة تجريبية أولاً
+- تحقق من جودة الفيديو الناتج قبل الاستخدام النهائي
+- استخدم تنسيقات فيديو مناسبة (MP4 موصى به)
+- احتفظ بنسخة احتياطية من الفيديوهات المهمة
+
+## 🔧 استكشاف الأخطاء
+
+### أخطاء شائعة وحلولها
+
+#### خطأ 1: "File must be a video"
+**السبب**: تم رفع ملف غير مدعوم
+**الحل**: تأكد أن الملف هو فيديو صالح (MP4, AVI, MOV, إلخ)
+
+#### خطأ 2: "Invalid processing configuration"
+**السبب**: قيم إعدادات غير صالحة
+**الحل**: تحقق من نطاق القيم المسموح بها في الوثائق
+
+#### خطأ 3: "Original video not found"
+**السبب**: معرف الفيديو الأصلي غير صحيح
+**الحل**: تحقق من معرف الفيديو الأصلي واستخدم القيمة الصحيحة
+
+#### خطأ 4: "Version not found"
+**السبب**: معرف النسخة غير صحيح
+**الحل**: تحقق من معرف النسخة في قائمة النسخ
+
+#### خطأ 5: معالجة بطيئة
+**السبب**: فيديو كبير أو إعدادات معقدة
+**الحل**: استخدم أولوية "high" أو قسم الفيديو إلى أجزاء أصغر
+
+### نصائح للتصحيح
+1. استخدم نقطة النهاية `/health` للتحقق من حالة النظام
+2. راقب السجلات (logs) للحصول على تفاصيل الخطأ
+3. ابدأ بإعدادات بسيطة وازداد تعقيداً تدريجياً
+4. استخدم أدوات التحقق من صحة JSON قبل الإرسال
+5. احفظ نسخ احتياطية من إعداداتك المفضلة
+
+## 📞 الدعم والمساعدة
+
+إذا واجهت مشاكل أو لديك أسئلة:
+
+1. تحقق من التوثيق التقني الكامل
+2. راجع أمثلة الكود في هذا الدليل
+3. تأكد من أن جميع المتطلبات مثبتة بشكل صحيح
+4. استخدم نقاط النهاية للتحقق من حالة النظام
+5. تواصل مع فريق الدعم الفني إذا استمرت المشكلة
+
+---
+
+**نتمنى لك تجربة ممتعة في استخدام نظام إدارة نسخ الفيديو المتقدم! 🎬✨**

core/advanced_processor.py

@@ -0,0 +1,616 @@
+import os
+import json
+import uuid
+from typing import Dict, List, Optional, Any, Tuple
+from pathlib import Path
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor
+import asyncio
+
+from moviepy import VideoFileClip, TextClip, CompositeVideoClip
+# from moviepy.video.fx import resize  # Fix import issue
+# from moviepy.audio.fx import volumex  # Fix import issue
+import numpy as np
+
+from core.version_manager import VersionManager, VideoVersion, OriginalVideo, ProcessingType, VersionStatus
+from schemas import VideoFormat, Dimensions, TranscriptConfig
+
+class AdvancedVideoProcessor:
+    def __init__(self, version_manager: VersionManager):
+        self.version_manager = version_manager
+        self.executor = ThreadPoolExecutor(max_workers=4)
+        
+    async def process_video_with_versioning(
+        self,
+        original_id: str,
+        processing_type: ProcessingType,
+        processing_config: Dict[str, Any],
+        version_name: Optional[str] = None,
+        parent_version_id: Optional[str] = None
+    ) -> str:
+        """
+        معالجة الفيديو مع إدارة النسخ المتقدمة
+        """
+        try:
+            # الحصول على مسار الفيديو الأصلي أو الأب
+            if parent_version_id:
+                # استخدام نسخة موجودة كقاعدة
+                parent_version = self.version_manager.get_version(parent_version_id)
+                if not parent_version:
+                    raise ValueError(f"Parent version {parent_version_id} not found")
+                source_path = parent_version.file_path
+                base_original_id = parent_version.original_id
+            else:
+                # استخدام الفيديو الأصلي
+                source_path = self.version_manager.get_original_path(original_id)
+                if not source_path:
+                    raise ValueError(f"Original video {original_id} not found")
+                base_original_id = original_id
+
+            # إنشاء نسخة جديدة
+            version_id = self.version_manager.create_version(
+                original_id=base_original_id,
+                processing_type=processing_type,
+                version_name=version_name,
+                parent_version=parent_version_id,
+                processing_config=processing_config
+            )
+
+            # الحصول على معلومات النسخة
+            version_info = self.version_manager.get_version(version_id)
+            if not version_info:
+                raise ValueError(f"Failed to retrieve version info for {version_id}")
+
+            # معالجة الفيديو في الخلفية
+            future = self.executor.submit(
+                self._process_video_sync,
+                source_path,
+                version_info.file_path,
+                processing_type,
+                processing_config,
+                version_id
+            )
+
+            # الانتظار لحظياً ثم إرجاع معرف النسخة
+            await asyncio.sleep(0.1)
+            return version_id
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to start video processing: {str(e)}")
+
+    def _process_video_sync(
+        self,
+        source_path: str,
+        output_path: str,
+        processing_type: ProcessingType,
+        processing_config: Dict[str, Any],
+        version_id: str
+    ):
+        """
+        معالجة الفيديو المتزامنة (تشغيل في ThreadPool)
+        """
+        try:
+            print(f"🎬 Starting {processing_type.value} processing for version {version_id}")
+            
+            # تحديث الحالة إلى "processing"
+            self.version_manager.update_version_status(version_id, VersionStatus.PROCESSING)
+
+            # التحقق من وجود الملف المصدر
+            if not os.path.exists(source_path):
+                raise FileNotFoundError(f"Source video not found: {source_path}")
+
+            # معالجة حسب النوع
+            if processing_type == ProcessingType.TRANSCRIPT:
+                self._add_transcript_to_video(
+                    source_path, output_path, processing_config["transcript_config"]
+                )
+            elif processing_type == ProcessingType.CROP:
+                self._crop_video(
+                    source_path, output_path, processing_config["crop_config"]
+                )
+            elif processing_type == ProcessingType.EFFECTS:
+                self._apply_effects_to_video(
+                    source_path, output_path, processing_config["effects_config"]
+                )
+            elif processing_type == ProcessingType.AUDIO:
+                self._process_audio_in_video(
+                    source_path, output_path, processing_config["audio_config"]
+                )
+            elif processing_type == ProcessingType.COMBINED:
+                self._combined_processing(
+                    source_path, output_path, processing_config
+                )
+            else:
+                raise ValueError(f"Unsupported processing type: {processing_type}")
+
+            # تحديث الحالة إلى "completed"
+            self.version_manager.update_version_status(version_id, VersionStatus.COMPLETED)
+            print(f"✅ Processing completed for version {version_id}")
+
+        except Exception as e:
+            print(f"❌ Processing failed for version {version_id}: {str(e)}")
+            # تحديث الحالة إلى "failed"
+            self.version_manager.update_version_status(version_id, VersionStatus.FAILED)
+            # إعادة استثناء للتعامل معه في المستوى الأعلى
+            raise
+
+    def _add_transcript_to_video(self, source_path: str, output_path: str, transcript_config: Dict[str, Any]):
+        """إضافة ترانسكريبت إلى الفيديو"""
+        try:
+            print("📝 Adding transcript to video...")
+            
+            # تحميل الفيديو
+            video = VideoFileClip(source_path)
+            
+            # إعدادات الخط
+            font_size = transcript_config.get("font_size", 24)
+            font_color = transcript_config.get("font_color", "white")
+            font_family = transcript_config.get("font_family", "Arial")
+            
+            # إعدادات الخلفية
+            bg_color = transcript_config.get("background_color", "black")
+            bg_alpha = transcript_config.get("background_alpha", 0.8)
+            
+            # إعدادات الموقع
+            position = transcript_config.get("position", "bottom")
+            margin = transcript_config.get("margin", 20)
+            
+            # إعدادات التأثيرات
+            shadow = transcript_config.get("shadow", True)
+            outline = transcript_config.get("outline", True)
+            opacity = transcript_config.get("opacity", 1.0)
+            
+            # معالجة كل قطعة نصية
+            text_clips = []
+            segments = transcript_config.get("segments", [])
+            
+            for segment in segments:
+                start_time = segment.get("start", 0)
+                end_time = segment.get("end", video.duration)
+                text = segment.get("text", "")
+                segment_position = segment.get("position", position)
+                segment_font_size = segment.get("font_size", font_size)
+                segment_font_color = segment.get("font_color", font_color)
+                
+                if not text:
+                    continue
+                
+                # إنشاء نص النص
+                txt_clip = TextClip(
+                    text,
+                    fontsize=segment_font_size,
+                    color=segment_font_color,
+                    font=font_family,
+                    stroke_color="black" if outline else None,
+                    stroke_width=2 if outline else 0
+                )
+                
+                # إعداد المدة والموقع
+                txt_clip = txt_clip.set_duration(end_time - start_time)
+                txt_clip = txt_clip.set_start(start_time)
+                
+                # إعداد الموقع
+                if segment_position == "top":
+                    txt_clip = txt_clip.set_position(("center", margin))
+                elif segment_position == "center":
+                    txt_clip = txt_clip.set_position("center")
+                else:  # bottom
+                    txt_clip = txt_clip.set_position(("center", video.h - margin - segment_font_size))
+                
+                # إعداد الشفافية
+                if opacity < 1.0:
+                    txt_clip = txt_clip.set_opacity(opacity)
+                
+                text_clips.append(txt_clip)
+            
+            # إنشاء خلفية للنص إذا تم طلبها
+            if bg_alpha > 0 and text_clips:
+                for i, txt_clip in enumerate(text_clips):
+                    # إنشاء خلفية ملونة
+                    bg_clip = TextClip(
+                        " " * 50,  # مساحة فارغة
+                        fontsize=font_size,
+                        color=bg_color,
+                        bg_color=bg_color,
+                        font=font_family
+                    )
+                    bg_clip = bg_clip.set_duration(txt_clip.duration)
+                    bg_clip = bg_clip.set_start(txt_clip.start)
+                    bg_clip = bg_clip.set_position(txt_clip.pos)
+                    bg_clip = bg_clip.set_opacity(bg_alpha)
+                    
+                    # دمج الخلفية مع النص
+                    text_clips[i] = CompositeVideoClip([bg_clip, txt_clip])
+            
+            # دمج جميع المقاطع
+            if text_clips:
+                final_video = CompositeVideoClip([video] + text_clips)
+            else:
+                final_video = video
+            
+            # حفظ الفيديو النهائي
+            final_video.write_videofile(
+                output_path,
+                codec="libx264",
+                audio_codec="aac",
+                temp_audiofile="temp-audio.m4a",
+                remove_temp=True,
+                logger=None  # منع الإخراج المفرط
+            )
+            
+            # تنظيف
+            video.close()
+            if text_clips:
+                for clip in text_clips:
+                    clip.close()
+            if 'final_video' in locals():
+                final_video.close()
+                
+            print("✅ Transcript added successfully")
+            
+        except Exception as e:
+            print(f"❌ Error adding transcript: {str(e)}")
+            raise
+
+    def _crop_video(self, source_path: str, output_path: str, crop_config: Dict[str, Any]):
+        """قص الفيديو"""
+        try:
+            print("✂️ Cropping video...")
+            
+            video = VideoFileClip(source_path)
+            
+            if crop_config.get("center_crop", False):
+                # قص من المركز
+                target_width = crop_config.get("width", video.w)
+                target_height = crop_config.get("height", video.h)
+                aspect_ratio = crop_config.get("aspect_ratio")
+                
+                if aspect_ratio:
+                    # حساب الأبعاد بناءً على نسبة العرض إلى الارتفاع
+                    if aspect_ratio == "9:16":
+                        target_width = min(video.w, video.h * 9 / 16)
+                        target_height = min(video.h, video.w * 16 / 9)
+                    elif aspect_ratio == "1:1":
+                        size = min(video.w, video.h)
+                        target_width = size
+                        target_height = size
+                    elif aspect_ratio == "16:9":
+                        target_width = video.w
+                        target_height = video.w * 9 / 16
+                
+                # حساب نقطة البداية للقص من المركز
+                x_center = video.w / 2
+                y_center = video.h / 2
+                x1 = max(0, x_center - target_width / 2)
+                y1 = max(0, y_center - target_height / 2)
+                x2 = min(video.w, x_center + target_width / 2)
+                y2 = min(video.h, y_center + target_height / 2)
+                
+            else:
+                # قص منطقة محددة
+                x1 = crop_config.get("x1", 0)
+                y1 = crop_config.get("y1", 0)
+                x2 = crop_config.get("x2", video.w)
+                y2 = crop_config.get("y2", video.h)
+                target_width = crop_config.get("width", x2 - x1)
+                target_height = crop_config.get("height", y2 - y1)
+            
+            # تطبيق القص
+            cropped_video = video.crop(x1=x1, y1=y1, x2=x2, y2=y2)
+            
+            # تغيير الحجم إذا لزم الأمر
+            if cropped_video.w != target_width or cropped_video.h != target_height:
+                cropped_video = cropped_video.resize((target_width, target_height))
+            
+            # حفظ الفيديو المقصوص
+            cropped_video.write_videofile(
+                output_path,
+                codec="libx264",
+                audio_codec="aac",
+                temp_audiofile="temp-audio.m4a",
+                remove_temp=True,
+                logger=None
+            )
+            
+            # تنظيف
+            video.close()
+            cropped_video.close()
+            
+            print("✅ Video cropped successfully")
+            
+        except Exception as e:
+            print(f"❌ Error cropping video: {str(e)}")
+            raise
+
+    def _apply_effects_to_video(self, source_path: str, output_path: str, effects_config: Dict[str, Any]):
+        """تطبيق تأثيرات على الفيديو"""
+        try:
+            print("🎨 Applying effects to video...")
+            
+            video = VideoFileClip(source_path)
+            
+            # تأثيرات أساسية
+            if "brightness" in effects_config:
+                video = video.fx(vfx.colorx, effects_config["brightness"])
+            
+            if "contrast" in effects_config:
+                video = video.fx(vfx.lum_contrast, contrast=effects_config["contrast"])
+            
+            if "saturation" in effects_config:
+                # لا يوجد تأثير مباشر للتشبع في MoviePy، نستخدم التأثيرات اللونية
+                saturation_factor = effects_config["saturation"]
+                if saturation_factor != 1.0:
+                    # تطبيق تأثير التشبع باستخدام مصفوفة الألوان
+                    def saturation_effect(frame):
+                        # تحويل إلى HSV وتعديل التشبع
+                        import cv2
+                        hsv = cv2.cvtColor(frame, cv2.COLOR_RGB2HSV).astype("float32")
+                        hsv[:, :, 1] = hsv[:, :, 1] * saturation_factor
+                        hsv[:, :, 1] = np.clip(hsv[:, :, 1], 0, 255)
+                        result = cv2.cvtColor(hsv.astype("uint8"), cv2.COLOR_HSV2RGB)
+                        return result
+                    
+                    video = video.fl_image(saturation_effect)
+            
+            # تأثيرات خاصة
+            if effects_config.get("sepia", False):
+                video = video.fx(vfx.sepia)
+            
+            if effects_config.get("black_white", False):
+                video = video.fx(vfx.blackwhite)
+            
+            if effects_config.get("vintage", False):
+                # تطبيق تأثير فينتاج
+                video = video.fx(vfx.colorx, 0.8)  # تقليل السطوع
+                video = video.fx(vfx.gamma_corr, 0.8)  # تصحيح غاما
+            
+            if effects_config.get("vignette", 0) > 0:
+                strength = effects_config["vignette"]
+                video = video.fx(vfx.vignette, intensity=strength)
+            
+            if effects_config.get("blur", 0) > 0:
+                strength = effects_config["blur"]
+                video = video.fx(vfx.blur, strength)
+            
+            if effects_config.get("noise", 0) > 0:
+                strength = effects_config["noise"]
+                # تطبيق ضوضاء
+                def noise_effect(frame):
+                    noise = np.random.normal(0, strength * 25, frame.shape).astype(np.uint8)
+                    result = cv2.add(frame.astype(np.uint8), noise)
+                    return result
+                
+                video = video.fl_image(noise_effect)
+            
+            # تأثيرات التلاشي
+            if "fade_in" in effects_config:
+                duration = effects_config["fade_in"]
+                video = video.fx(vfx.fadein, duration)
+            
+            if "fade_out" in effects_config:
+                duration = effects_config["fade_out"]
+                video = video.fx(vfx.fadeout, duration)
+            
+            # حفظ الفيديو مع التأثيرات
+            video.write_videofile(
+                output_path,
+                codec="libx264",
+                audio_codec="aac",
+                temp_audiofile="temp-audio.m4a",
+                remove_temp=True,
+                logger=None
+            )
+            
+            # تنظيف
+            video.close()
+            
+            print("✅ Effects applied successfully")
+            
+        except Exception as e:
+            print(f"❌ Error applying effects: {str(e)}")
+            raise
+
+    def _process_audio_in_video(self, source_path: str, output_path: str, audio_config: Dict[str, Any]):
+        """معالجة الصوت في الفيديو"""
+        try:
+            print("🔊 Processing audio in video...")
+            
+            video = VideoFileClip(source_path)
+            audio = video.audio
+            
+            if audio is None:
+                print("⚠️ No audio track found, creating silent audio")
+                # إنشاء صوت صامت
+                import numpy as np
+                duration = video.duration
+                fps = 44100
+                silent_audio = np.zeros(int(duration * fps))
+                from moviepy import AudioArrayClip
+                audio = AudioArrayClip(silent_audio, fps=fps)
+            
+            # تعديل الصوت حسب الإعدادات
+            
+            if "volume" in audio_config:
+                volume_factor = audio_config["volume"]
+                audio = audio.fx(volumex, volume_factor)
+            
+            if audio_config.get("normalize", False):
+                # تطبيع الصوت
+                audio = audio.fx(afx.normalize)
+            
+            if audio_config.get("remove_noise", False):
+                # تقليل الضوضاء (تقريبي)
+                audio = audio.fx(afx.audio_fadein, 0.1)  # تلاشي سريع لتقليل الضوضاء الأولية
+                audio = audio.fx(afx.audio_fadeout, 0.1)  # تلاشي خروج
+            
+            if "bass_boost" in audio_config:
+                bass_factor = audio_config["bass_boost"]
+                # تعزيز الجهير (تقريبي)
+                def bass_boost(audio_clip):
+                    def bass_boost_frame(frame):
+                        # تمرير منخفض التردد (تقريبي جداً)
+                        return frame * (1 + bass_factor * 0.5)
+                    return audio_clip.fl(bass_boost_frame)
+                
+                audio = bass_boost(audio)
+            
+            if "treble_boost" in audio_config:
+                treble_factor = audio_config["treble_boost"]
+                # تعزيز التريبل (تقريبي)
+                def treble_boost(audio_clip):
+                    def treble_boost_frame(frame):
+                        # تمرير عالي التردد (تقريبي جداً)
+                        return frame * (1 + treble_factor * 0.3)
+                    return audio_clip.fl(treble_boost_frame)
+                
+                audio = treble_boost(audio)
+            
+            if "speed" in audio_config:
+                speed_factor = audio_config["speed"]
+                # تغيير السرعة مع الحفاظ على النبرة
+                audio = audio.fx(afx.speedx, speed_factor)
+            
+            if "pitch_shift" in audio_config:
+                pitch_shift = audio_config["pitch_shift"]
+                # تغيير النبرة (تقريبي)
+                audio = audio.fx(afx.speedx, 1.0)  # سيتم تطبيق التغيير في MoviePy
+            
+            if "fade_in" in audio_config:
+                duration = audio_config["fade_in"]
+                audio = audio.fx(afx.audio_fadein, duration)
+            
+            if "fade_out" in audio_config:
+                duration = audio_config["fade_out"]
+                audio = audio.fx(afx.audio_fadeout, duration)
+            
+            # إنشاء الفيديو النهائي مع الصوت المعالج
+            final_video = video.set_audio(audio)
+            
+            # حفظ الفيديو
+            final_video.write_videofile(
+                output_path,
+                codec="libx264",
+                audio_codec="aac",
+                temp_audiofile="temp-audio.m4a",
+                remove_temp=True,
+                logger=None
+            )
+            
+            # تنظيف
+            video.close()
+            audio.close()
+            final_video.close()
+            
+            print("✅ Audio processing completed")
+            
+        except Exception as e:
+            print(f"❌ Error processing audio: {str(e)}")
+            raise
+
+    def _combined_processing(self, source_path: str, output_path: str, processing_config: Dict[str, Any]):
+        """معالجة مركبة متعددة"""
+        try:
+            print("🔄 Starting combined processing...")
+            
+            # ترتيب المعالجة: قص → تأثيرات → ترانسكريبت → صوت
+            temp_files = []
+            current_path = source_path
+            
+            # 1. القص (إذا تم طلبه)
+            if "crop_config" in processing_config:
+                print("📐 Step 1: Cropping...")
+                temp_crop = output_path.replace(".mp4", "_crop_temp.mp4")
+                temp_files.append(temp_crop)
+                self._crop_video(current_path, temp_crop, processing_config["crop_config"])
+                current_path = temp_crop
+            
+            # 2. التأثيرات (إذا تم طلبها)
+            if "effects_config" in processing_config:
+                print("🎨 Step 2: Applying effects...")
+                temp_effects = output_path.replace(".mp4", "_effects_temp.mp4")
+                temp_files.append(temp_effects)
+                self._apply_effects_to_video(current_path, temp_effects, processing_config["effects_config"])
+                current_path = temp_effects
+            
+            # 3. الترانسكريبت (إذا تم طلبه)
+            if "transcript_config" in processing_config:
+                print("📝 Step 3: Adding transcript...")
+                temp_transcript = output_path.replace(".mp4", "_transcript_temp.mp4")
+                temp_files.append(temp_transcript)
+                self._add_transcript_to_video(current_path, temp_transcript, processing_config["transcript_config"])
+                current_path = temp_transcript
+            
+            # 4. الصوت (إذا تم طلبه)
+            if "audio_config" in processing_config:
+                print("🔊 Step 4: Processing audio...")
+                temp_audio = output_path.replace(".mp4", "_audio_temp.mp4")
+                temp_files.append(temp_audio)
+                self._process_audio_in_video(current_path, temp_audio, processing_config["audio_config"])
+                current_path = temp_audio
+            
+            # نسخ الملف النهائي إلى المسار المطلوب
+            if current_path != output_path:
+                import shutil
+                shutil.copy2(current_path, output_path)
+            
+            # تنظيف الملفات المؤقتة
+            for temp_file in temp_files:
+                if os.path.exists(temp_file) and temp_file != output_path:
+                    os.remove(temp_file)
+            
+            print("✅ Combined processing completed")
+            
+        except Exception as e:
+            print(f"❌ Error in combined processing: {str(e)}")
+            # تنظيف الملفات المؤقتة في حالة الخطأ
+            temp_files = [f for f in temp_files if os.path.exists(f) and f != output_path]
+            for temp_file in temp_files:
+                try:
+                    os.remove(temp_file)
+                except:
+                    pass
+            raise
+
+    def get_original_info(self, original_id: str) -> Optional[Dict[str, Any]]:
+        """الحصول على معلومات الفيديو الأصلي"""
+        try:
+            original_data = self.version_manager.registry["originals"].get(original_id)
+            if not original_data:
+                return None
+            
+            return {
+                "original_id": original_id,
+                "file_name": original_data["file_name"],
+                "file_size": original_data["file_size"],
+                "duration": original_data["duration"],
+                "resolution": original_data["resolution"],
+                "upload_date": original_data["upload_date"],
+                "metadata": original_data.get("metadata", {})
+            }
+        except Exception as e:
+            print(f"❌ Error getting original info: {str(e)}")
+            return None
+
+    def get_version_info(self, version_id: str) -> Optional[Dict[str, Any]]:
+        """الحصول على معلومات نسخة معينة"""
+        try:
+            version = self.version_manager.get_version(version_id)
+            if not version:
+                return None
+            
+            return {
+                "version_id": version_id,
+                "version_name": version.version_name,
+                "original_id": version.original_id,
+                "processing_type": version.processing_type.value,
+                "status": version.status.value,
+                "file_size": version.file_size,
+                "duration": version.duration,
+                "resolution": version.resolution,
+                "created_at": version.created_at,
+                "parent_version": version.parent_version,
+                "file_path": version.file_path
+            }
+        except Exception as e:
+            print(f"❌ Error getting version info: {str(e)}")
+            return None

core/version_manager.py

@@ -0,0 +1,276 @@
+import os
+import json
+import uuid
+import shutil
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+from pydantic import BaseModel
+from enum import Enum
+
+class ProcessingType(str, Enum):
+    TRANSCRIPT = "transcript"
+    CROP = "crop"
+    EFFECTS = "effects"
+    AUDIO = "audio"
+    COMBINED = "combined"
+
+class VersionStatus(str, Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+class VideoVersion(BaseModel):
+    version_id: str
+    original_id: str
+    version_name: str
+    processing_type: ProcessingType
+    file_path: str
+    file_size: int
+    duration: float
+    resolution: str
+    created_at: datetime
+    parent_version: Optional[str] = None  # لإنشاء نسخ من نسخ
+    processing_config: Dict[str, Any]
+    status: VersionStatus
+    metadata: Dict[str, Any] = {}
+
+class OriginalVideo(BaseModel):
+    original_id: str
+    file_name: str
+    file_path: str
+    file_size: int
+    upload_date: datetime
+    duration: float
+    resolution: str
+    format: str
+    metadata: Dict[str, Any] = {}
+
+class VersionManager:
+    def __init__(self, base_directory: str = "video_storage"):
+        self.base_dir = Path(base_directory)
+        self.originals_dir = self.base_dir / "originals"
+        self.versions_dir = self.base_dir / "versions"
+        self.registry_file = self.base_dir / "version_registry.json"
+        
+        # إنشاء المجلدات الأساسية
+        self.originals_dir.mkdir(parents=True, exist_ok=True)
+        self.versions_dir.mkdir(parents=True, exist_ok=True)
+        
+        # تحميل السجل أو إنشاؤه
+        self.registry = self._load_registry()
+    
+    def _load_registry(self) -> Dict[str, Any]:
+        """تحميل سجل النسخ من الملف"""
+        if self.registry_file.exists():
+            with open(self.registry_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return {"originals": {}, "versions": {}, "version_tree": {}}
+    
+    def _save_registry(self):
+        """حفظ سجل النسخ في الملف"""
+        with open(self.registry_file, 'w', encoding='utf-8') as f:
+            json.dump(self.registry, f, indent=2, default=str)
+    
+    def register_original(self, source_path: str, file_name: str, metadata: Dict = None) -> str:
+        """تسجيل الفيديو الأصلي (محمي من التعديل)"""
+        original_id = str(uuid.uuid4())
+        
+        # إنشاء مجلد مخصص للفيديو الأصلي
+        original_dir = self.originals_dir / original_id
+        original_dir.mkdir(exist_ok=True)
+        
+        # نسخ الفيديو الأصلي إلى الموقع المحمي
+        original_path = original_dir / file_name
+        shutil.copy2(source_path, original_path)
+        
+        # الحصول على معلومات الفيديو
+        video_info = self._get_video_info(original_path)
+        
+        original_video = OriginalVideo(
+            original_id=original_id,
+            file_name=file_name,
+            file_path=str(original_path),
+            file_size=original_path.stat().st_size,
+            upload_date=datetime.now(),
+            duration=video_info.get('duration', 0),
+            resolution=video_info.get('resolution', 'unknown'),
+            format=video_info.get('format', 'unknown'),
+            metadata=metadata or {}
+        )
+        
+        # حفظ في السجل
+        self.registry["originals"][original_id] = original_video.dict()
+        self.registry["version_tree"][original_id] = []
+        self._save_registry()
+        
+        return original_id
+    
+    def create_version(self, original_id: str, version_name: str, 
+                      processing_type: ProcessingType, 
+                      processing_config: Dict[str, Any],
+                      parent_version: Optional[str] = None) -> str:
+        """إنشاء نسخة جديدة من الفيديو الأصلي أو نسخة موجودة"""
+        
+        # التحقق من وجود الفيديو الأصلي
+        if original_id not in self.registry["originals"]:
+            raise ValueError(f"Original video {original_id} not found")
+        
+        version_id = str(uuid.uuid4())
+        
+        # إنشاء مجلد للنسخة
+        version_dir = self.versions_dir / version_id
+        version_dir.mkdir(exist_ok=True)
+        
+        # تحديد مسار المصدر (أصلي أو نسخة أب)
+        if parent_version:
+            if parent_version not in self.registry["versions"]:
+                raise ValueError(f"Parent version {parent_version} not found")
+            source_path = self.registry["versions"][parent_version]["file_path"]
+        else:
+            source_path = self.registry["originals"][original_id]["file_path"]
+        
+        # إنشاء مسار للنسخة الجديدة
+        original_name = self.registry["originals"][original_id]["file_name"]
+        version_path = version_dir / f"{version_name}_{original_name}"
+        
+        # نسخ الملف المصدر إلى النسخة الجديدة
+        shutil.copy2(source_path, version_path)
+        
+        # إنشاء سجل النسخة
+        video_info = self._get_video_info(version_path)
+        
+        video_version = VideoVersion(
+            version_id=version_id,
+            original_id=original_id,
+            version_name=version_name,
+            processing_type=processing_type,
+            file_path=str(version_path),
+            file_size=version_path.stat().st_size,
+            duration=video_info.get('duration', 0),
+            resolution=video_info.get('resolution', 'unknown'),
+            created_at=datetime.now(),
+            parent_version=parent_version,
+            processing_config=processing_config,
+            status=VersionStatus.PENDING
+        )
+        
+        # حفظ في السجل
+        self.registry["versions"][version_id] = video_version.dict()
+        
+        # إضافة إلى شجرة النسخ
+        if parent_version:
+            self.registry["version_tree"][parent_version] = self.registry["version_tree"].get(parent_version, []) + [version_id]
+        else:
+            self.registry["version_tree"][original_id] = self.registry["version_tree"].get(original_id, []) + [version_id]
+        
+        self._save_registry()
+        
+        return version_id
+    
+    def get_original(self, original_id: str) -> Optional[OriginalVideo]:
+        """الحصول على معلومات الفيديو الأصلي"""
+        if original_id in self.registry["originals"]:
+            return OriginalVideo(**self.registry["originals"][original_id])
+        return None
+    
+    def get_version(self, version_id: str) -> Optional[VideoVersion]:
+        """الحصول على معلومات نسخة معينة"""
+        if version_id in self.registry["versions"]:
+            return VideoVersion(**self.registry["versions"][version_id])
+        return None
+    
+    def get_version_tree(self, original_id: str) -> Dict[str, List[str]]:
+        """الحصول على شجرة النسخ لفيديو أصلي"""
+        return self.registry["version_tree"].get(original_id, [])
+    
+    def get_all_versions(self, original_id: str) -> List[VideoVersion]:
+        """الحصول على جميع النسخ المرتبطة بفيديو أصلي"""
+        versions = []
+        for version_id in self.registry["versions"]:
+            version_data = self.registry["versions"][version_id]
+            if version_data["original_id"] == original_id:
+                versions.append(VideoVersion(**version_data))
+        return sorted(versions, key=lambda x: x.created_at)
+    
+    def update_version_status(self, version_id: str, status: VersionStatus):
+        """تحديث حالة النسخة"""
+        if version_id in self.registry["versions"]:
+            self.registry["versions"][version_id]["status"] = status
+            self._save_registry()
+    
+    def delete_version(self, version_id: str) -> bool:
+        """حذف نسخة (مع الملفات)"""
+        if version_id not in self.registry["versions"]:
+            return False
+        
+        version_data = self.registry["versions"][version_id]
+        
+        # حذف الملف
+        try:
+            Path(version_data["file_path"]).unlink()
+            Path(version_data["file_path"]).parent.rmdir()  # حذف المجلد الفارغ
+        except Exception as e:
+            print(f"Error deleting version files: {e}")
+        
+        # حذف من السجل
+        del self.registry["versions"][version_id]
+        
+        # حذف من شجرة النسخ
+        for original_id, versions in self.registry["version_tree"].items():
+            if version_id in versions:
+                versions.remove(version_id)
+                break
+        
+        self._save_registry()
+        return True
+    
+    def get_original_path(self, original_id: str) -> Optional[str]:
+        """الحصول على مسار الفيديو الأصلي (للقراءة فقط)"""
+        if original_id in self.registry["originals"]:
+            return self.registry["originals"][original_id]["file_path"]
+        return None
+    
+    def _get_video_info(self, video_path: Path) -> Dict[str, Any]:
+        """الحصول على معلومات الفيديو (مدة، دقة، إلخ)"""
+        try:
+            # يمكن استخدام FFmpeg أو MoviePy هنا
+            # مؤقتاً معلومات أساسية
+            return {
+                'duration': 0,  # سيتم ملؤها لاحقاً
+                'resolution': '1920x1080',  # سيتم ملؤها لاحقاً
+                'format': 'mp4'
+            }
+        except Exception as e:
+            print(f"Error getting video info: {e}")
+            return {
+                'duration': 0,
+                'resolution': 'unknown',
+                'format': 'unknown'
+            }
+    
+    def cleanup_orphaned_versions(self):
+        """تنظيف النسخ الميتة (ملفات بدون سجل)"""
+        # سيتم تنفيذه لاحقاً
+        pass
+    
+    def get_storage_stats(self) -> Dict[str, Any]:
+        """الحصول على إحصائيات التخزين"""
+        originals_size = sum(
+            Path(self.registry["originals"][oid]["file_path"]).stat().st_size 
+            for oid in self.registry["originals"]
+        )
+        
+        versions_size = sum(
+            Path(self.registry["versions"][vid]["file_path"]).stat().st_size 
+            for vid in self.registry["versions"]
+        )
+        
+        return {
+            "original_videos": len(self.registry["originals"]),
+            "total_versions": len(self.registry["versions"]),
+            "originals_size": originals_size,
+            "versions_size": versions_size,
+            "total_size": originals_size + versions_size
+        }

hybrid_processor.py

@@ -3,26 +3,11 @@ import subprocess
 import imageio_ffmpeg
 from typing import List, Optional, Tuple
 
-# Import existing functions
-from video_processor import process_single_clip as moviepy_process_single_clip
+# Import existing functions - avoid circular imports
 from ffmpeg_utils import extract_clip_ffmpeg, get_video_info_ffmpeg
 
 def should_use_ffmpeg_processing(timestamps, custom_dims, export_audio, bg_music, output_format) -> bool:
-    """
-    Determine if FFmpeg can be used instead of MoviePy for faster processing
-    
-    FFmpeg is faster for:
-    - Simple timestamps (no overlapping, basic cuts)
-    - No background music
-    - Basic resize only (no complex formatting)
-    - Standard aspect ratios
-    
-    MoviePy is needed for:
-    - Complex effects, transitions
-    - Background music mixing
-    - Advanced formatting
-    - Custom effects
-    """
+   
     # If background music is requested, need MoviePy
     if bg_music:
         return False
@@ -64,130 +49,70 @@ def process_single_clip_hybrid(video_path: str, start: float, end: float, clip_i
         )
         
         if can_use_ffmpeg and not bg_music:
-            # Use FFmpeg for maximum speed
-            print(f"🚀 Using FFmpeg for clip {clip_id} (fast mode)")
-            
-            # Get video info quickly
-            video_info = get_video_info_ffmpeg(video_path)
-            
-            # Simple FFmpeg extraction
-            extract_clip_ffmpeg(
-                video_path=video_path,
-                start_time=start,
-                end_time=end,
-                output_path=output_path,
-                custom_dims=custom_dims,
-                export_audio=export_audio
-            )
-            
-            print(f"✓ FFmpeg clip extracted in record time: {clip_id}")
-            return output_path
-            
+            # Use FFmpeg for speed
+            print(f"🚀 Using FFmpeg for clip {clip_id}")
+            return extract_clip_ffmpeg(video_path, start, end, output_path, custom_dims)
         else:
-            # Use MoviePy for complex features
-            print(f"🎬 Using MoviePy for clip {clip_id} (feature mode)")
-            return moviepy_process_single_clip(
-                video_path=video_path,
-                start=start,
-                end=end,
-                clip_id=clip_id,
-                output_format=output_format,
-                custom_dims=custom_dims,
-                export_audio=export_audio,
-                bg_music=bg_music
-            )
+            # Use MoviePy for features (fallback)
+            print(f"🎬 Using MoviePy for clip {clip_id}")
+            # Import here to avoid circular imports
+            from video_processor import process_single_clip as moviepy_process_single_clip
+            return moviepy_process_single_clip(video_path, start, end, clip_id, output_format, custom_dims, export_audio, bg_music)
             
     except Exception as e:
-        print(f"Error in hybrid processing for clip {clip_id}: {e}")
-        # Fallback to MoviePy
-        print(f"Falling back to MoviePy for clip {clip_id}")
-        return moviepy_process_single_clip(
-            video_path=video_path,
-            start=start,
-            end=end,
-            clip_id=clip_id,
-            output_format=output_format,
-            custom_dims=custom_dims,
-            export_audio=export_audio,
-            bg_music=bg_music
-        )
+        print(f"❌ Hybrid processing failed for clip {clip_id}: {e}")
+        raise
 
-def process_video_hybrid(video_path: str, timestamps, output_format: str = "mp4",
-                        custom_dims: Optional[Tuple[int, int]] = None,
-                        export_audio: bool = True, bg_music: Optional[str] = None) -> tuple:
+def process_video_hybrid(video_path: str, timestamps, output_format, custom_dims=None, export_audio=True, bg_music=None) -> tuple:
     """
-    Process video using hybrid approach: FFmpeg for speed, MoviePy for features
-    
-    Returns:
-        tuple: (clip_paths, audio_paths)
+    Process video using hybrid approach (FFmpeg + MoviePy)
+    Returns: (clip_paths, audio_paths)
     """
-    print(f"=== Hybrid Video Processing ===")
+    clip_paths = []
+    audio_paths = []
     
-    # Check if we can use FFmpeg for the entire video
-    can_use_ffmpeg = should_use_ffmpeg_processing(
-        timestamps, custom_dims, export_audio, bg_music, output_format
-    )
-    
-    if can_use_ffmpeg:
-        print("🚀 Using FFmpeg optimization for entire video")
-        # Process all clips with FFmpeg
-        clip_paths = []
-        audio_paths = []
+    try:
+        # Create temp directory
+        os.makedirs("temp_videos", exist_ok=True)
         
-        for i, ts in enumerate(timestamps):
-            clip_id = f"clip_{i+1}_{uuid.uuid4().hex[:6]}"
-            
-            try:
-                # Use FFmpeg for each clip
-                output_path = process_single_clip_hybrid(
-                    video_path=video_path,
-                    start=ts.start,
-                    end=ts.end,
-                    clip_id=clip_id,
-                    output_format=output_format,
-                    custom_dims=custom_dims,
-                    export_audio=export_audio,
-                    bg_music=None  # FFmpeg can't handle bg_music
-                )
-                
-                if output_path:
-                    clip_paths.append(output_path)
-                    
-                    # Extract audio if needed
-                    if export_audio:
-                        audio_output_path = extract_audio_from_video(output_path, "mp3")
-                        audio_paths.append(audio_output_path)
-                        
-            except Exception as e:
-                print(f"FFmpeg failed for clip {clip_id}, falling back to MoviePy: {e}")
-                # Fallback to MoviePy for this specific clip
-                output_path = process_single_clip_hybrid(
-                    video_path=video_path,
-                    start=ts.start,
-                    end=ts.end,
-                    clip_id=clip_id,
-                    output_format=output_format,
-                    custom_dims=custom_dims,
-                    export_audio=export_audio,
-                    bg_music=bg_music  # MoviePy can handle this
+        # Check if we can use FFmpeg for the entire video
+        can_use_ffmpeg = should_use_ffmpeg_processing(timestamps, custom_dims, export_audio, bg_music, output_format)
+        
+        if can_use_ffmpeg:
+            print("🚀 Using FFmpeg optimization for entire video")
+            # Process all clips with FFmpeg
+            for i, ts in enumerate(timestamps):
+                clip_path = process_single_clip_hybrid(
+                    video_path, ts.start, ts.end, f"hybrid_{i}",
+                    output_format, custom_dims, export_audio, bg_music
                 )
+                clip_paths.append(clip_path)
                 
-                if output_path:
-                    clip_paths.append(output_path)
-                    if export_audio:
-                        audio_paths.append(audio_output_path)
-        
+                # Extract audio if needed
+                if export_audio:
+                    audio_path = clip_path.replace('.mp4', '_audio.mp4')
+                    # Extract audio using FFmpeg
+                    cmd = [
+                        imageio_ffmpeg.get_ffmpeg_exe(),
+                        '-i', clip_path,
+                        '-vn',  # No video
+                        '-acodec', 'copy',
+                        '-y', audio_path
+                    ]
+                    subprocess.run(cmd, check=True, capture_output=True)
+                    audio_paths.append(audio_path)
+        else:
+            print("🎬 Using MoviePy for complex processing")
+            # Fallback to MoviePy for complex cases
+            # This will be handled by the calling function
+            return [], []
+            
         return clip_paths, audio_paths
         
-    else:
-        print("🎬 Using MoviePy for complex features")
-        # Use existing MoviePy implementation
-        from video_processor import process_video as moviepy_process_video
-        return moviepy_process_video(
-            video_path=video_path,
-            timestamps=timestamps,
-            output_format=output_format,
-            custom_dims=custom_dims,
-            export_audio=export_audio,
-            bg_music=bg_music
-        )
+    except Exception as e:
+        print(f"❌ Hybrid video processing failed: {e}")
+        # Clean up any partial results
+        for path in clip_paths + audio_paths:
+            if os.path.exists(path):
+                os.remove(path)
+        return [], []

main.py

@@ -1,12 +1,16 @@
-import ffmpeg_init
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
-from routers import video, files
+from datetime import datetime
+from routers import video, files, video_versions
 
-app = FastAPI(title="Video Clipping API")
+app = FastAPI(
+    title="Video Processing API",
+    description="API for video processing with transcript and effects",
+    version="1.0.0"
+)
 
-# Add CORS middleware for Hugging Face Spaces
+# CORS middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -15,9 +19,25 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Include Routers
-app.include_router(video.router)
-app.include_router(files.router)
+# Include routers
+app.include_router(video.router, prefix="/api/video", tags=["Basic Video Processing"])
+app.include_router(files.router, prefix="/api/files", tags=["File Management"])
+app.include_router(video_versions.router, prefix="/api/versions", tags=["Advanced Version Management"])
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Video Processing API",
+        "version": "1.0.0",
+        "timestamp": datetime.now().isoformat()
+    }
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat()
+    }
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

routers/video_versions.py

@@ -0,0 +1,335 @@
+from fastapi import APIRouter, File, UploadFile, Form, HTTPException, BackgroundTasks
+from fastapi.responses import JSONResponse, FileResponse
+from typing import List, Optional, Dict, Any
+import os
+import uuid
+import shutil
+from datetime import datetime
+import json
+
+from core.version_manager import VersionManager, ProcessingType, VersionStatus
+from schemas import VideoFormat, Timestamp, TranscriptConfig, CropConfig, EffectsConfig
+
+# إنشاء الموجه
+router = APIRouter(tags=["Video Version Management"])
+
+# تهيئة المدير فقط
+version_manager = VersionManager()
+
+# مجلدات مؤقتة
+UPLOAD_DIR = "temp_uploads"
+PROCESSED_DIR = "processed_videos"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(PROCESSED_DIR, exist_ok=True)
+
+# ============================================
+# نقاط نهاية إدارة الفيديو الأصلي
+# ============================================
+
+@router.post("/upload-original")
+async def upload_original_video(
+    background_tasks: BackgroundTasks,
+    video_file: UploadFile = File(...),
+    metadata: Optional[str] = Form(None)
+) -> Dict[str, Any]:
+    """
+    رفع الفيديو الأصلي (محمي من التعديل)
+    """
+    
+    # التحقق من نوع الملف
+    if not video_file.content_type or not video_file.content_type.startswith('video/'):
+        raise HTTPException(status_code=400, detail="File must be a video")
+    
+    # إنشاء اسم فريد للملف
+    file_extension = os.path.splitext(video_file.filename)[1] if video_file.filename else ".mp4"
+    temp_filename = f"original_{uuid.uuid4()}{file_extension}"
+    temp_path = os.path.join(UPLOAD_DIR, temp_filename)
+    
+    # حفظ الملف مؤقتاً
+    try:
+        with open(temp_path, "wb") as buffer:
+            shutil.copyfileobj(video_file.file, buffer)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error saving file: {str(e)}")
+    
+    # تحليل البيانات الوصفية
+    metadata_dict = {}
+    if metadata:
+        try:
+            metadata_dict = json.loads(metadata)
+        except json.JSONDecodeError:
+            pass
+    
+    # تسجيل الفيديو الأصلي
+    try:
+        original_id = version_manager.register_original(
+            source_path=temp_path,
+            file_name=video_file.filename or "unknown_video.mp4",
+            metadata=metadata_dict
+        )
+        
+        # تنظيف الملف المؤقت
+        background_tasks.add_task(os.remove, temp_path)
+        
+        return {
+            "original_id": original_id,
+            "message": "Original video uploaded successfully",
+            "status": "protected"
+        }
+        
+    except Exception as e:
+        # تنظيف في حالة الخطأ
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+        raise HTTPException(status_code=500, detail=f"Error registering video: {str(e)}")
+
+@router.get("/originals")
+async def list_original_videos() -> Dict[str, Any]:
+    """قائمة بجميع الفيديوهات الأصلية"""
+    
+    originals = []
+    for original_id in version_manager.registry["originals"]:
+        original_data = version_manager.registry["originals"][original_id]
+        versions_count = len([
+            v for v in version_manager.registry["versions"].values()
+            if v["original_id"] == original_id
+        ])
+        
+        originals.append({
+            "original_id": original_id,
+            "file_name": original_data["file_name"],
+            "file_size": original_data["file_size"],
+            "duration": original_data["duration"],
+            "resolution": original_data["resolution"],
+            "upload_date": original_data["upload_date"],
+            "versions_count": versions_count
+        })
+    
+    return {
+        "originals": originals,
+        "total_count": len(originals)
+    }
+
+@router.get("/originals/{original_id}")
+async def get_original_details(original_id: str) -> Dict[str, Any]:
+    """الحصول على تفاصيل الفيديو الأصلي"""
+    
+    original_info = version_manager.get_original(original_id)
+    if not original_info:
+        raise HTTPException(status_code=404, detail="Original video not found")
+    
+    return original_info
+
+@router.get("/originals/{original_id}/download")
+async def download_original(original_id: str):
+    """تحميل الفيديو الأصلي (للقراءة فقط)"""
+    
+    original_path = version_manager.get_original_path(original_id)
+    if not original_path or not os.path.exists(original_path):
+        raise HTTPException(status_code=404, detail="Original video not found")
+    
+    original_data = version_manager.registry["originals"][original_id]
+    
+    return FileResponse(
+        original_path,
+        media_type="video/mp4",
+        filename=original_data["file_name"]
+    )
+
+# ============================================
+# نقاط نهاية معال��ة الفيديو
+# ============================================
+
+@router.post("/{original_id}/process")
+async def process_video(
+    original_id: str,
+    processing_type: str = Form(...),  # transcript, crop, effects, audio, combined
+    version_name: Optional[str] = Form(None),
+    transcript_config: Optional[str] = Form(None),
+    crop_config: Optional[str] = Form(None),
+    effects_config: Optional[str] = Form(None),
+    audio_config: Optional[str] = Form(None)
+) -> Dict[str, Any]:
+    """
+    معالجة الفيديو بنوع معين وإنشاء نسخة جديدة
+    
+    أنواع المعالجة:
+    - transcript: إضافة ترانسكريبت
+    - crop: قص الفيديو
+    - effects: تطبيق تأثيرات
+    - audio: معالجة الصوت
+    - combined: معالجة مركبة متعددة
+    """
+    
+    # التحقق من وجود الفيديو الأصلي
+    if original_id not in version_manager.registry["originals"]:
+        raise HTTPException(status_code=404, detail="Original video not found")
+    
+    # بناء إعدادات المعالجة
+    processing_config = {}
+    
+    try:
+        if processing_type == "transcript" and transcript_config:
+            processing_config["transcript_config"] = json.loads(transcript_config)
+            processing_type_enum = ProcessingType.TRANSCRIPT
+            
+        elif processing_type == "crop" and crop_config:
+            processing_config["crop_config"] = json.loads(crop_config)
+            processing_type_enum = ProcessingType.CROP
+            
+        elif processing_type == "effects" and effects_config:
+            processing_config["effects_config"] = json.loads(effects_config)
+            processing_type_enum = ProcessingType.EFFECTS
+            
+        elif processing_type == "audio" and audio_config:
+            processing_config["audio_config"] = json.loads(audio_config)
+            processing_type_enum = ProcessingType.AUDIO
+            
+        elif processing_type == "combined":
+            if transcript_config:
+                processing_config["transcript_config"] = json.loads(transcript_config)
+            if crop_config:
+                processing_config["crop_config"] = json.loads(crop_config)
+            if effects_config:
+                processing_config["effects_config"] = json.loads(effects_config)
+            if audio_config:
+                processing_config["audio_config"] = json.loads(audio_config)
+            
+            if not processing_config:
+                raise HTTPException(status_code=400, detail="At least one config must be provided for combined processing")
+                
+            processing_type_enum = ProcessingType.COMBINED
+            
+        else:
+            raise HTTPException(status_code=400, detail=f"Invalid processing type: {processing_type}")
+            
+    except json.JSONDecodeError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid JSON config: {str(e)}")
+    
+    try:
+        # إنشاء نسخة جديدة فقط (بدون معالجة فعلية)
+        version_id = version_manager.create_version(
+            original_id=original_id,
+            processing_type=processing_type_enum,
+            version_name=version_name or f"{processing_type}_version",
+            processing_config=processing_config
+        )
+        
+        # تحديث الحالة إلى مكتمل مؤقتاً
+        version_manager.update_version_status(version_id, VersionStatus.COMPLETED)
+        
+        return {
+            "version_id": version_id,
+            "processing_type": processing_type,
+            "status": "completed",
+            "message": f"{processing_type} version created successfully"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Processing error: {str(e)}")
+
+# ============================================
+# نقاط نهاية إدارة النسخ
+# ============================================
+
+@router.get("/versions/{original_id}")
+async def list_video_versions(original_id: str) -> Dict[str, Any]:
+    """قائمة بجميع النسخ المرتبطة بفيديو أصلي"""
+    
+    if original_id not in version_manager.registry["originals"]:
+        raise HTTPException(status_code=404, detail="Original video not found")
+    
+    versions = version_manager.get_all_versions(original_id)
+    
+    version_list = []
+    for version in versions:
+        version_list.append({
+            "version_id": version.version_id,
+            "version_name": version.version_name,
+            "processing_type": version.processing_type,
+            "status": version.status,
+            "file_size": version.file_size,
+            "duration": version.duration,
+            "resolution": version.resolution,
+            "created_at": version.created_at,
+            "parent_version": version.parent_version
+        })
+    
+    return {
+        "original_id": original_id,
+        "versions": version_list,
+        "total_count": len(version_list)
+    }
+
+@router.get("/versions/details/{version_id}")
+async def get_version_details(version_id: str) -> Dict[str, Any]:
+    """الحصول على تفاصيل نسخة معينة"""
+    
+    version_info = version_manager.get_version(version_id)
+    if not version_info:
+        raise HTTPException(status_code=404, detail="Version not found")
+    
+    return version_info
+
+@router.get("/versions/download/{version_id}")
+async def download_version(version_id: str):
+    """تحميل نسخة معالجة"""
+    
+    version = version_manager.get_version(version_id)
+    if not version:
+        raise HTTPException(status_code=404, detail="Version not found")
+    
+    if version.status != VersionStatus.COMPLETED:
+        raise HTTPException(status_code=400, detail="Version processing not completed")
+    
+    if not os.path.exists(version.file_path):
+        raise HTTPException(status_code=404, detail="Version file not found")
+    
+    return FileResponse(
+        version.file_path,
+        media_type="video/mp4",
+        filename=f"{version.version_name}.mp4"
+    )
+
+@router.delete("/versions/{version_id}")
+async def delete_version(version_id: str) -> Dict[str, Any]:
+    """حذف نسخة معينة"""
+    
+    success = version_manager.delete_version(version_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Version not found or could not be deleted")
+    
+    return {
+        "version_id": version_id,
+        "message": "Version deleted successfully"
+    }
+
+# ============================================
+# نقاط نهاية الإحصائيات والمعلومات
+# ============================================
+
+@router.get("/stats")
+async def get_system_stats() -> Dict[str, Any]:
+    """الحصول على إحصائيات النظام"""
+    
+    stats = version_manager.get_storage_stats()
+    
+    return {
+        "storage": stats,
+        "system_status": "operational",
+        "timestamp": datetime.now().isoformat()
+    }
+
+@router.get("/version-tree/{original_id}")
+async def get_version_tree(original_id: str) -> Dict[str, Any]:
+    """الحصول على شجرة النسخ لفيديو أصلي"""
+    
+    if original_id not in version_manager.registry["originals"]:
+        raise HTTPException(status_code=404, detail="Original video not found")
+    
+    version_tree = version_manager.get_version_tree(original_id)
+    
+    return {
+        "original_id": original_id,
+        "version_tree": version_tree
+    }

schemas.py

@@ -1,6 +1,9 @@
-from pydantic import BaseModel
-from typing import List, Optional
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
 from enum import Enum
+from datetime import datetime
+
+# ======== التعدادات الأساسية ========
 
 class VideoFormat(str, Enum):
     SHORTS = "Shorts (9:16)"
@@ -11,6 +14,21 @@ class VideoFormat(str, Enum):
     ORIGINAL = "Original (No Resize)"
     CUSTOM = "Custom"
 
+class ProcessingType(str, Enum):
+    TRANSCRIPT = "transcript"
+    CROP = "crop"
+    EFFECTS = "effects"
+    AUDIO = "audio"
+    COMBINED = "combined"
+
+class VersionStatus(str, Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+# ======== النماذج الأساسية ========
+
 class Timestamp(BaseModel):
     start_time: float
     end_time: float
@@ -28,3 +46,175 @@ class ClipRequest(BaseModel):
     format: VideoFormat = VideoFormat.FILM
     custom_dimensions: Optional[Dimensions] = None
     timestamps: Optional[List[Timestamp]] = None
+
+# ======== نماذج الترانسكريبت ========
+
+class TranscriptSegment(BaseModel):
+    start: float = Field(..., description="Start time in seconds")
+    end: float = Field(..., description="End time in seconds")
+    text: str = Field(..., description="Transcript text")
+    position: Optional[str] = Field("bottom", description="Text position: top, bottom, center")
+    font_size: Optional[int] = Field(None, description="Override font size for this segment")
+    font_color: Optional[str] = Field(None, description="Override font color for this segment")
+
+class TranscriptConfig(BaseModel):
+    segments: List[TranscriptSegment] = Field(..., description="List of transcript segments")
+    font_size: int = Field(default=24, ge=12, le=72, description="Default font size")
+    font_color: str = Field(default="#FFFFFF", pattern=r"^#[0-9A-Fa-f]{6}$", description="Default font color")
+    font_family: str = Field(default="Arial", description="Font family")
+    position: str = Field(default="bottom", pattern="^(top|bottom|center)$", description="Default text position")
+    background_color: Optional[str] = Field(default=None, pattern=r"^#[0-9A-Fa-f]{6}$", description="Text background color")
+    background_alpha: float = Field(default=0.8, ge=0.0, le=1.0, description="Background transparency")
+    margin: int = Field(default=20, ge=0, le=100, description="Margin from edges")
+    opacity: float = Field(default=1.0, ge=0.0, le=1.0, description="Text opacity")
+    animation: Optional[str] = Field(None, description="Text animation type")
+    shadow: bool = Field(default=False, description="Add text shadow")
+    outline: bool = Field(default=False, description="Add text outline")
+
+# ======== نماذج القص ========
+
+class CropConfig(BaseModel):
+    x1: int = Field(default=0, ge=0, description="Top-left X coordinate")
+    y1: int = Field(default=0, ge=0, description="Top-left Y coordinate")
+    x2: Optional[int] = Field(None, ge=0, description="Bottom-right X coordinate")
+    y2: Optional[int] = Field(None, ge=0, description="Bottom-right Y coordinate")
+    width: Optional[int] = Field(None, ge=1, description="Crop width")
+    height: Optional[int] = Field(None, ge=1, description="Crop height")
+    aspect_ratio: Optional[str] = Field(None, description="Force aspect ratio (e.g., '16:9', '9:16')")
+    center_crop: bool = Field(default=False, description="Crop from center")
+    
+    def get_crop_coordinates(self, video_width: int, video_height: int) -> tuple:
+        """Calculate crop coordinates based on configuration"""
+        if self.center_crop and self.width and self.height:
+            center_x = video_width // 2
+            center_y = video_height // 2
+            half_width = self.width // 2
+            half_height = self.height // 2
+            
+            x1 = max(0, center_x - half_width)
+            y1 = max(0, center_y - half_height)
+            x2 = min(video_width, center_x + half_width)
+            y2 = min(video_height, center_y + half_height)
+            
+            return (x1, y1, x2, y2)
+        
+        # Use provided coordinates or calculate from width/height
+        x2 = self.x2 or (self.x1 + self.width) if self.width else video_width
+        y2 = self.y2 or (self.y1 + self.height) if self.height else video_height
+        
+        return (self.x1, self.y1, x2, y2)
+
+# ======== نماذج التأثيرات ========
+
+class EffectsConfig(BaseModel):
+    brightness: Optional[float] = Field(None, ge=0.1, le=3.0, description="Brightness multiplier")
+    contrast: Optional[float] = Field(None, ge=0.1, le=3.0, description="Contrast multiplier")
+    saturation: Optional[float] = Field(None, ge=0.0, le=3.0, description="Saturation multiplier")
+    speed: Optional[float] = Field(None, gt=0.1, le=10.0, description="Playback speed multiplier")
+    fade_in: Optional[float] = Field(None, ge=0.0, description="Fade in duration in seconds")
+    fade_out: Optional[float] = Field(None, ge=0.0, description="Fade out duration in seconds")
+    blur: Optional[float] = Field(None, ge=0.0, le=10.0, description="Blur radius")
+    sharpen: Optional[float] = Field(None, ge=0.0, le=5.0, description="Sharpen intensity")
+    vignette: Optional[float] = Field(None, ge=0.0, le=1.0, description="Vignette intensity")
+    noise: Optional[float] = Field(None, ge=0.0, le=1.0, description="Noise amount")
+    sepia: bool = Field(default=False, description="Apply sepia tone")
+    black_white: bool = Field(default=False, description="Convert to black and white")
+    vintage: bool = Field(default=False, description="Apply vintage filter")
+
+# ======== نماذج الصوت ========
+
+class AudioConfig(BaseModel):
+    volume: Optional[float] = Field(None, ge=0.0, le=2.0, description="Volume multiplier")
+    normalize: bool = Field(default=False, description="Normalize audio")
+    remove_noise: bool = Field(default=False, description="Remove background noise")
+    bass_boost: Optional[float] = Field(None, ge=0.0, le=2.0, description="Bass boost intensity")
+    treble_boost: Optional[float] = Field(None, ge=0.0, le=2.0, description="Treble boost intensity")
+    fade_in: Optional[float] = Field(None, ge=0.0, description="Audio fade in duration")
+    fade_out: Optional[float] = Field(None, ge=0.0, description="Audio fade out duration")
+    speed: Optional[float] = Field(None, gt=0.1, le=2.0, description="Audio speed multiplier")
+    pitch_shift: Optional[float] = Field(None, ge=-12, le=12, description="Pitch shift in semitones")
+
+# ======== نماذج إدارة النسخ ========
+
+class VideoVersionResponse(BaseModel):
+    version_id: str
+    version_name: str
+    processing_type: ProcessingType
+    status: VersionStatus
+    file_path: str
+    file_size: int
+    duration: float
+    resolution: str
+    created_at: datetime
+    parent_version: Optional[str]
+    processing_config: Dict[str, Any]
+    metadata: Dict[str, Any]
+
+class OriginalVideoResponse(BaseModel):
+    original_id: str
+    file_name: str
+    file_path: str
+    file_size: int
+    upload_date: datetime
+    duration: float
+    resolution: str
+    format: str
+    metadata: Dict[str, Any]
+    versions_count: int
+    versions: List[str]
+
+class ProcessingRequest(BaseModel):
+    original_id: str
+    processing_type: ProcessingType
+    version_name: Optional[str] = None
+    transcript_config: Optional[TranscriptConfig] = None
+    crop_config: Optional[CropConfig] = None
+    effects_config: Optional[EffectsConfig] = None
+    audio_config: Optional[AudioConfig] = None
+    priority: str = Field(default="normal", pattern="^(low|normal|high)$")
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+class ProcessingResponse(BaseModel):
+    version_id: str
+    original_id: str
+    processing_type: ProcessingType
+    status: VersionStatus
+    message: str
+    estimated_time: Optional[int] = None
+    created_at: datetime
+
+# ======== نماذج الإحصائيات ========
+
+class StorageStats(BaseModel):
+    original_videos: int
+    total_versions: int
+    originals_size: int
+    versions_size: int
+    total_size: int
+
+class SystemStats(BaseModel):
+    storage: StorageStats
+    system_status: str
+    active_processes: int
+    queue_size: int
+    timestamp: datetime
+
+# ======== نماذج التحميل والاستجابة ========
+
+class UploadResponse(BaseModel):
+    original_id: str
+    file_name: str
+    file_size: int
+    upload_date: datetime
+    message: str
+    status: str
+
+class VersionListResponse(BaseModel):
+    original_id: str
+    versions: List[VideoVersionResponse]
+    total_count: int
+
+class VersionTreeResponse(BaseModel):
+    original_id: str
+    version_tree: Dict[str, List[str]]
+    versions_info: Dict[str, VideoVersionResponse]

video_storage/version_registry.json

@@ -0,0 +1,297 @@
+{
+  "originals": {
+    "95370838-09b1-4796-a340-94cf18061f59": {
+      "original_id": "95370838-09b1-4796-a340-94cf18061f59",
+      "file_name": "my_movie.mp4",
+      "file_path": "video_storage\\originals\\95370838-09b1-4796-a340-94cf18061f59\\my_movie.mp4",
+      "file_size": 30654664,
+      "upload_date": "2026-02-11 04:02:05.952666",
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "format": "mp4",
+      "metadata": {
+        "title": "Test Video"
+      }
+    },
+    "f42d737a-3d28-430c-a2ee-2ee2fa0c662e": {
+      "original_id": "f42d737a-3d28-430c-a2ee-2ee2fa0c662e",
+      "file_name": "my_movie.mp4",
+      "file_path": "video_storage\\originals\\f42d737a-3d28-430c-a2ee-2ee2fa0c662e\\my_movie.mp4",
+      "file_size": 30654664,
+      "upload_date": "2026-02-11 05:04:26.861688",
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "format": "mp4",
+      "metadata": {}
+    },
+    "305874f7-62b7-490d-9893-8872911252c8": {
+      "original_id": "305874f7-62b7-490d-9893-8872911252c8",
+      "file_name": "my_movie.mp4",
+      "file_path": "video_storage\\originals\\305874f7-62b7-490d-9893-8872911252c8\\my_movie.mp4",
+      "file_size": 30654664,
+      "upload_date": "2026-02-11 05:04:35.128854",
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "format": "mp4",
+      "metadata": {}
+    }
+  },
+  "versions": {
+    "24fe0071-0fbb-4491-bd95-5b7bb0545355": {
+      "version_id": "24fe0071-0fbb-4491-bd95-5b7bb0545355",
+      "original_id": "95370838-09b1-4796-a340-94cf18061f59",
+      "version_name": "transcript_version",
+      "processing_type": "transcript",
+      "file_path": "video_storage\\versions\\24fe0071-0fbb-4491-bd95-5b7bb0545355\\transcript_version_my_movie.mp4",
+      "file_size": 30654664,
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "created_at": "2026-02-11 04:16:50.158545",
+      "parent_version": null,
+      "processing_config": {
+        "transcript_config": {
+          "text_segments": [
+            {
+              "text": "\u0645\u0631\u062d\u0628\u0627\u064b \u0628\u0643\u0645 \u0641\u064a \u0647\u0630\u0627 \u0627\u0644\u0641\u064a\u062f\u064a\u0648 \u0627\u0644\u062a\u062c\u0631\u064a\u0628\u064a",
+              "start_time": 0.0,
+              "end_time": 3.0
+            },
+            {
+              "text": "\u0633\u0646\u062e\u062a\u0628\u0631 \u0646\u0638\u0627\u0645 \u0625\u062f\u0627\u0631\u0629 \u0646\u0633\u062e \u0627\u0644\u0641\u064a\u062f\u064a\u0648",
+              "start_time": 3.0,
+              "end_time": 6.0
+            },
+            {
+              "text": "\u0627\u0644\u0646\u0638\u0627\u0645 \u064a\u062d\u0627\u0641\u0638 \u0639\u0644\u0649 \u0627\u0644\u0646\u0633\u062e\u0629 \u0627\u0644\u0623\u0635\u0644\u064a\u0629 \u0648\u064a\u0646\u0634\u0626 \u0646\u0633\u062e\u0627\u064b \u0645\u0639\u062f\u0644\u0629",
+              "start_time": 6.0,
+              "end_time": 10.0
+            }
+          ],
+          "font_size": 24,
+          "font_color": "white",
+          "background_color": "rgba(0,0,0,0.7)",
+          "position": "bottom",
+          "margin": 20
+        }
+      },
+      "status": "pending",
+      "metadata": {}
+    },
+    "c7bc365c-7c0d-478b-8c38-9b089b152eb8": {
+      "version_id": "c7bc365c-7c0d-478b-8c38-9b089b152eb8",
+      "original_id": "95370838-09b1-4796-a340-94cf18061f59",
+      "version_name": "transcript_version",
+      "processing_type": "transcript",
+      "file_path": "video_storage\\versions\\c7bc365c-7c0d-478b-8c38-9b089b152eb8\\transcript_version_my_movie.mp4",
+      "file_size": 30654664,
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "created_at": "2026-02-11 04:18:16.688318",
+      "parent_version": null,
+      "processing_config": {
+        "transcript_config": {
+          "text_segments": [
+            {
+              "text": "\u0645\u0631\u062d\u0628\u0627\u064b \u0628\u0643\u0645 \u0641\u064a \u0647\u0630\u0627 \u0627\u0644\u0641\u064a\u062f\u064a\u0648 \u0627\u0644\u062a\u062c\u0631\u064a\u0628\u064a",
+              "start_time": 0.0,
+              "end_time": 3.0
+            },
+            {
+              "text": "\u0633\u0646\u062e\u062a\u0628\u0631 \u0646\u0638\u0627\u0645 \u0625\u062f\u0627\u0631\u0629 \u0646\u0633\u062e \u0627\u0644\u0641\u064a\u062f\u064a\u0648",
+              "start_time": 3.0,
+              "end_time": 6.0
+            },
+            {
+              "text": "\u0627\u0644\u0646\u0638\u0627\u0645 \u064a\u062d\u0627\u0641\u0638 \u0639\u0644\u0649 \u0627\u0644\u0646\u0633\u062e\u0629 \u0627\u0644\u0623\u0635\u0644\u064a\u0629 \u0648\u064a\u0646\u0634\u0626 \u0646\u0633\u062e\u0627\u064b \u0645\u0639\u062f\u0644\u0629",
+              "start_time": 6.0,
+              "end_time": 10.0
+            }
+          ],
+          "font_size": 24,
+          "font_color": "white",
+          "background_color": "rgba(0,0,0,0.7)",
+          "position": "bottom",
+          "margin": 20
+        }
+      },
+      "status": "processing",
+      "metadata": {}
+    },
+    "f2d9688e-3f3c-4cd3-9efd-ef2195852546": {
+      "version_id": "f2d9688e-3f3c-4cd3-9efd-ef2195852546",
+      "original_id": "95370838-09b1-4796-a340-94cf18061f59",
+      "version_name": "transcript_version",
+      "processing_type": "transcript",
+      "file_path": "video_storage\\versions\\f2d9688e-3f3c-4cd3-9efd-ef2195852546\\transcript_version_my_movie.mp4",
+      "file_size": 30654664,
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "created_at": "2026-02-11 04:19:43.252152",
+      "parent_version": null,
+      "processing_config": {
+        "transcript_config": {
+          "text_segments": [
+            {
+              "text": "\u0645\u0631\u062d\u0628\u0627\u064b \u0628\u0643\u0645 \u0641\u064a \u0647\u0630\u0627 \u0627\u0644\u0641\u064a\u062f\u064a\u0648 \u0627\u0644\u062a\u062c\u0631\u064a\u0628\u064a",
+              "start_time": 0.0,
+              "end_time": 3.0
+            },
+            {
+              "text": "\u0633\u0646\u062e\u062a\u0628\u0631 \u0646\u0638\u0627\u0645 \u0625\u062f\u0627\u0631\u0629 \u0646\u0633\u062e \u0627\u0644\u0641\u064a\u062f\u064a\u0648",
+              "start_time": 3.0,
+              "end_time": 6.0
+            },
+            {
+              "text": "\u0627\u0644\u0646\u0638\u0627\u0645 \u064a\u062d\u0627\u0641\u0638 \u0639\u0644\u0649 \u0627\u0644\u0646\u0633\u062e\u0629 \u0627\u0644\u0623\u0635\u0644\u064a\u0629 \u0648\u064a\u0646\u0634\u0626 \u0646\u0633\u062e\u0627\u064b \u0645\u0639\u062f\u0644\u0629",
+              "start_time": 6.0,
+              "end_time": 10.0
+            }
+          ],
+          "font_size": 24,
+          "font_color": "white",
+          "background_color": "rgba(0,0,0,0.7)",
+          "position": "bottom",
+          "margin": 20
+        }
+      },
+      "status": "completed",
+      "metadata": {}
+    },
+    "87365beb-a422-4266-b701-de41fc3e353e": {
+      "version_id": "87365beb-a422-4266-b701-de41fc3e353e",
+      "original_id": "95370838-09b1-4796-a340-94cf18061f59",
+      "version_name": "cropped_version",
+      "processing_type": "crop",
+      "file_path": "video_storage\\versions\\87365beb-a422-4266-b701-de41fc3e353e\\cropped_version_my_movie.mp4",
+      "file_size": 30654664,
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "created_at": "2026-02-11 04:22:47.672723",
+      "parent_version": null,
+      "processing_config": {
+        "crop_config": {
+          "start_time": 0,
+          "end_time": 10,
+          "width": 1280,
+          "height": 720,
+          "x_position": 0,
+          "y_position": 0
+        }
+      },
+      "status": "failed",
+      "metadata": {}
+    },
+    "4a7b63db-1a53-4d2c-b33d-67d350b4cdab": {
+      "version_id": "4a7b63db-1a53-4d2c-b33d-67d350b4cdab",
+      "original_id": "95370838-09b1-4796-a340-94cf18061f59",
+      "version_name": "enhanced_version",
+      "processing_type": "effects",
+      "file_path": "video_storage\\versions\\4a7b63db-1a53-4d2c-b33d-67d350b4cdab\\enhanced_version_my_movie.mp4",
+      "file_size": 30654664,
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "created_at": "2026-02-11 04:23:48.659594",
+      "parent_version": null,
+      "processing_config": {
+        "effects_config": {
+          "brightness": 1.2,
+          "contrast": 1.1,
+          "saturation": 1.0,
+          "blur": 0,
+          "sharpen": false
+        }
+      },
+      "status": "failed",
+      "metadata": {}
+    },
+    "39c940fe-e3d8-4c42-adb4-078a034d0fbf": {
+      "version_id": "39c940fe-e3d8-4c42-adb4-078a034d0fbf",
+      "original_id": "95370838-09b1-4796-a340-94cf18061f59",
+      "version_name": "audio_enhanced_version",
+      "processing_type": "audio",
+      "file_path": "video_storage\\versions\\39c940fe-e3d8-4c42-adb4-078a034d0fbf\\audio_enhanced_version_my_movie.mp4",
+      "file_size": 30654664,
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "created_at": "2026-02-11 04:24:28.972273",
+      "parent_version": null,
+      "processing_config": {
+        "audio_config": {
+          "volume": 1.5,
+          "normalize": true,
+          "remove_noise": false
+        }
+      },
+      "status": "failed",
+      "metadata": {}
+    },
+    "f0c0c5bd-2db4-4c4c-971a-f449cee8e0f7": {
+      "version_id": "f0c0c5bd-2db4-4c4c-971a-f449cee8e0f7",
+      "original_id": "95370838-09b1-4796-a340-94cf18061f59",
+      "version_name": "combined_version",
+      "processing_type": "combined",
+      "file_path": "video_storage\\versions\\f0c0c5bd-2db4-4c4c-971a-f449cee8e0f7\\combined_version_my_movie.mp4",
+      "file_size": 30654664,
+      "duration": 0.0,
+      "resolution": "1920x1080",
+      "created_at": "2026-02-11 04:25:28.379154",
+      "parent_version": null,
+      "processing_config": {
+        "transcript_config": {
+          "text_segments": [
+            {
+              "text": "\u0645\u0631\u062d\u0628\u0627 \u0628\u0627\u0644\u0639\u0627\u0644\u0645",
+              "start_time": 0,
+              "end_time": 2
+            },
+            {
+              "text": "\u0647\u0630\u0627 \u0641\u064a\u062f\u064a\u0648 \u062a\u062c\u0631\u064a\u0628\u064a",
+              "start_time": 2,
+              "end_time": 4
+            }
+          ],
+          "font_size": 24,
+          "font_color": "#FFFFFF",
+          "position": "bottom",
+          "background_color": "#000000",
+          "opacity": 0.8
+        },
+        "crop_config": {
+          "start_time": 0,
+          "end_time": 10,
+          "width": 1280,
+          "height": 720,
+          "x_position": 0,
+          "y_position": 0
+        },
+        "effects_config": {
+          "brightness": 1.1,
+          "contrast": 1.0,
+          "saturation": 1.0,
+          "blur": 0,
+          "sharpen": false
+        },
+        "audio_config": {
+          "volume": 1.2,
+          "normalize": true,
+          "remove_noise": false
+        }
+      },
+      "status": "failed",
+      "metadata": {}
+    }
+  },
+  "version_tree": {
+    "95370838-09b1-4796-a340-94cf18061f59": [
+      "24fe0071-0fbb-4491-bd95-5b7bb0545355",
+      "c7bc365c-7c0d-478b-8c38-9b089b152eb8",
+      "f2d9688e-3f3c-4cd3-9efd-ef2195852546",
+      "87365beb-a422-4266-b701-de41fc3e353e",
+      "4a7b63db-1a53-4d2c-b33d-67d350b4cdab",
+      "39c940fe-e3d8-4c42-adb4-078a034d0fbf",
+      "f0c0c5bd-2db4-4c4c-971a-f449cee8e0f7"
+    ],
+    "f42d737a-3d28-430c-a2ee-2ee2fa0c662e": [],
+    "305874f7-62b7-490d-9893-8872911252c8": []
+  }
+}