Upload 3 files

app.py

@@ -1,33 +1,14 @@
 import gradio as gr
 import yt_dlp
 import aiohttp
-from aiohttp_proxy import ProxyConnector
 import asyncio
 import os
 import tempfile
-from urllib.parse import urlparse, parse_qs, urlencode
+from urllib.parse import urlparse
 import time
 import mimetypes
 import concurrent.futures
 import math
-import json
-from datetime import datetime
-import random
-from bs4 import BeautifulSoup
-import re
-import urllib3
-import uuid
-import ssl
-import undetected_chromedriver as uc
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-import threading
-from fake_useragent import UserAgent
-import requests
-
-# تعطيل تحذيرات SSL
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
 class FastDownloader:
     def __init__(self):
@@ -35,612 +16,22 @@ class FastDownloader:
             'format': 'best',
             'quiet': True,
             'no_warnings': True,
-            'concurrent_fragments': 10,
-            'nocheckcertificate': True,
+            'concurrent_fragments': 10,  # زيادة عدد التحميلات المتزامنة
         }
-        self.chunk_size = 1024 * 1024 * 5
-        self.max_workers = 5
-        self.archive_file = "download_archive.json"
-        
-        # إنشاء UserAgent عشوائي
-        self.ua = UserAgent()
-        
-        # إعداد SSL context
-        self.ssl_context = ssl.create_default_context()
-        self.ssl_context.check_hostname = False
-        self.ssl_context.verify_mode = ssl.CERT_NONE
-        
-        # تهيئة المتصفح
-        self.driver = None
-        self.driver_lock = threading.Lock()
-        
-        # تهيئة الأرشيف
-        self.load_archive()
-        
-        # تهيئة قائمة البروكسيات
-        self.proxies = []
-        self.update_proxies()
-
-    def update_proxies(self):
-        """تحديث قائمة البروكسيات"""
-        fallback_proxies = [
-            'http://51.159.115.233:3128',
-            'http://20.111.54.16:8123',
-            'http://51.159.115.233:3128',
-            'http://20.206.106.192:80',
-            'http://51.79.50.31:9300'
-        ]
-        
-        try:
-            # محاولة الحصول على بروكسيات من مصدر خارجي
-            response = requests.get(
-                'https://proxylist.geonode.com/api/proxy-list',
-                params={
-                    'limit': '100',
-                    'page': '1',
-                    'sort_by': 'lastChecked',
-                    'sort_type': 'desc',
-                    'protocols': 'http,https',
-                    'anonymityLevel': 'elite,anonymous'
-                },
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                if isinstance(data, dict) and 'data' in data:
-                    for proxy in data['data']:
-                        protocol = proxy.get('protocols', ['http'])[0]
-                        ip = proxy.get('ip')
-                        port = proxy.get('port')
-                        if ip and port:
-                            self.proxies.append(f'{protocol}://{ip}:{port}')
-            
-            # إضافة البروكسيات الاحتياطية
-            self.proxies.extend(fallback_proxies)
-            
-        except Exception as e:
-            print(f"Error updating proxies: {str(e)}")
-            # استخدام البروكسيات الاحتياطية في حالة الفشل
-            self.proxies = fallback_proxies.copy()
-
-    def get_random_proxy(self):
-        """الحصول على بروكسي عشوائي"""
-        # تحديث البروكسيات إذا كانت القائمة فارغة
-        if not self.proxies:
-            self.update_proxies()
-        
-        # إرجاع بروكسي عشوائي إذا كانت هناك بروكسيات متاحة
-        return random.choice(self.proxies) if self.proxies else None
-
-    def get_headers(self, url):
-        """إنشاء ترويسات عشوائية"""
-        parsed_url = urlparse(url)
-        domain = parsed_url.netloc.lower()
-        
-        headers = {
-            'User-Agent': self.ua.random,
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.9,ar;q=0.8',
-            'Accept-Encoding': 'gzip, deflate, br',
-            'Connection': 'keep-alive',
-            'Upgrade-Insecure-Requests': '1',
-            'Cache-Control': 'max-age=0',
-            'TE': 'Trailers',
-            'DNT': '1',
-            'Sec-GPC': '1',
-            'Pragma': 'no-cache'
-        }
-        
-        if 'milocdn' in domain or 'anime4up' in domain:
-            headers.update({
-                'Referer': f"https://{domain}/",
-                'Origin': f"https://{domain}",
-                'Host': domain,
-                'Sec-Fetch-Dest': 'document',
-                'Sec-Fetch-Mode': 'navigate',
-                'Sec-Fetch-Site': 'same-origin',
-                'Sec-Fetch-User': '?1',
-                'X-Requested-With': f'XMLHttpRequest-{random.randint(1000, 9999)}',
-                'X-Forwarded-For': f'192.168.{random.randint(1, 255)}.{random.randint(1, 255)}'
-            })
-        
-        return headers
-
-    def get_cookies(self, url):
-        """إنشاء كوكيز عشوائية"""
-        domain = urlparse(url).netloc
-        timestamp = int(time.time())
-        cookies = {
-            'cf_clearance': f"{uuid.uuid4().hex}",
-            '_ga': f"GA1.2.{random.randint(1000000, 9999999)}.{timestamp}",
-            '_gid': f"GA1.2.{random.randint(1000000, 9999999)}.{timestamp}",
-            'PHPSESSID': f"{uuid.uuid4().hex}",
-            'visited': '1',
-            'last_visit': str(timestamp),
-            'session_depth': str(random.randint(1, 5)),
-            'user_preferences': 'theme=light',
-            'timezone_offset': '-180',
-            '_fbp': f"fb.1.{timestamp}.{random.randint(1000000, 9999999)}",
-            '_ym_uid': f"{random.randint(1000000000, 9999999999)}",
-            '_ym_d': str(timestamp),
-            'wordpress_test_cookie': 'WP Cookie check',
-            'wp-settings-time-1': str(timestamp),
-        }
-        return cookies
-
-    def init_browser(self):
-        """تهيئة المتصفح"""
-        try:
-            options = uc.ChromeOptions()
-            options.add_argument('--headless')
-            options.add_argument('--no-sandbox')
-            options.add_argument('--disable-dev-shm-usage')
-            options.add_argument('--disable-gpu')
-            options.add_argument(f'--user-agent={self.ua.random}')
-            
-            # Set Chrome binary location for different platforms
-            if os.name == 'nt':  # Windows
-                chrome_paths = [
-                    r"C:\Program Files\Google\Chrome\Application\chrome.exe",
-                    r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
-                ]
-                for path in chrome_paths:
-                    if os.path.exists(path):
-                        options.binary_location = path
-                        break
-            else:  # Linux/Unix
-                chrome_paths = [
-                    "/usr/bin/google-chrome",
-                    "/usr/bin/chromium-browser",
-                ]
-                for path in chrome_paths:
-                    if os.path.exists(path):
-                        options.binary_location = path
-                        break
-            
-            with self.driver_lock:
-                if not self.driver:
-                    self.driver = uc.Chrome(options=options)
-        except Exception as e:
-            print(f"Warning: Browser initialization failed: {str(e)}")
-            self.driver = None
-
-    def close_browser(self):
-        """إغلاق المتصفح"""
-        with self.driver_lock:
-            if self.driver:
-                try:
-                    self.driver.quit()
-                except:
-                    pass
-                self.driver = None
-
-    async def extract_direct_link(self, url):
-        """استخراج رابط التحميل المباشر"""
-        try:
-            # Parse URL components
-            parsed = urlparse(url)
-            query_params = parse_qs(parsed.query)
-            
-            # If URL already has a token, try to refresh it
-            if 't' in query_params:
-                current_time = int(time.time())
-                # Generate new token parameters
-                new_params = {
-                    't': query_params.get('t', [''])[0],
-                    's': str(current_time),
-                    'e': '86400',
-                    'f': query_params.get('f', [''])[0],
-                    'sp': '1000',
-                    'i': '0.0'
-                }
-                
-                # Reconstruct URL with new parameters
-                base_url = f"{parsed.scheme}://{parsed.netloc}{parsed.path}"
-                new_url = f"{base_url}?{urlencode(new_params)}"
-                return new_url
-            
-            return url
-        except Exception:
-            return url
-
-    async def download_with_ytdlp(self, url, browser_cookies=None, use_proxy=False):
-        """استخدام yt-dlp للتحميل"""
-        try:
-            temp_dir = tempfile.mkdtemp()
-            
-            # Try to refresh/extract direct link
-            url = await self.extract_direct_link(url)
-            
-            # Enhanced headers with streaming-specific settings
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-                'Accept': '*/*',
-                'Accept-Language': 'en-US,en;q=0.9',
-                'Accept-Encoding': 'gzip, deflate, br',
-                'Connection': 'keep-alive',
-                'Range': 'bytes=0-',
-                'Referer': url,
-                'Origin': urlparse(url).scheme + '://' + urlparse(url).netloc,
-                'Sec-Fetch-Dest': 'video',
-                'Sec-Fetch-Mode': 'cors',
-                'Sec-Fetch-Site': 'same-origin',
-            }
-            
-            # Get cookies
-            if not browser_cookies:
-                browser_cookies = self.get_cookies(url)
-            
-            # Custom format selection
-            format_selector = lambda ctx: [{
-                'format_id': 'best',
-                'ext': 'mp4',
-                'protocol': 'https'
-            }]
-            
-            ydl_opts = {
-                'format': 'best',
-                'format_sort': ['res:1080', 'ext:mp4:m4a'],
-                'outtmpl': os.path.join(temp_dir, '%(title)s.%(ext)s'),
-                'quiet': True,
-                'no_warnings': True,
-                'nocheckcertificate': True,
-                'http_headers': headers,
-                'socket_timeout': 30,
-                'retries': 3,
-                'fragment_retries': 3,
-                'retry_sleep_functions': {'fragment': lambda n: min(5 * (n + 1), 30)},
-                'format_selector': format_selector,
-                'concurrent_fragment_downloads': 10,
-                'file_access_retries': 5,
-                'hls_prefer_native': True,
-                'hls_split_discontinuity': True,
-                'downloader': 'native',
-                'downloader_options': {
-                    'http_chunk_size': 10485760,  # 10MB
-                }
-            }
-            
-            # Prepare cookies
-            cookies_file = os.path.join(temp_dir, 'cookies.txt')
-            with open(cookies_file, 'w', encoding='utf-8') as f:
-                domain = f".{urlparse(url).netloc}"
-                expire_time = int(time.time()) + 86400 * 7  # 7 days
-                for k, v in browser_cookies.items():
-                    f.write(f"{domain}\tTRUE\t/\tFALSE\t{expire_time}\t{k}\t{v}\n")
-            ydl_opts['cookies'] = cookies_file
-            
-            # First try direct download
-            try:
-                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                    info = ydl.extract_info(url, download=True)
-                    filename = ydl.prepare_filename(info)
-            except Exception as e:
-                if not use_proxy:
-                    raise
-                
-                # If direct download fails, try with proxies
-                proxies = []
-                for _ in range(3):
-                    proxy = self.get_random_proxy()
-                    if proxy and proxy not in proxies:
-                        try:
-                            async with aiohttp.ClientSession() as session:
-                                async with session.head('https://www.google.com', 
-                                                    proxy=proxy, 
-                                                    timeout=5,
-                                                    ssl=False) as resp:
-                                    if resp.status == 200:
-                                        proxies.append(proxy)
-                        except Exception:
-                            continue
-                
-                if not proxies:
-                    # Try one last time with direct connection
-                    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                        info = ydl.extract_info(url, download=True)
-                        filename = ydl.prepare_filename(info)
-                else:
-                    # Try each working proxy
-                    last_error = None
-                    for proxy in proxies:
-                        try:
-                            ydl_opts['proxy'] = proxy
-                            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                                info = ydl.extract_info(url, download=True)
-                                filename = ydl.prepare_filename(info)
-                            break
-                        except Exception as e:
-                            last_error = e
-                            continue
-                    else:
-                        # If all proxies fail, try one last time without proxy
-                        ydl_opts['proxy'] = None
-                        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                            info = ydl.extract_info(url, download=True)
-                            filename = ydl.prepare_filename(info)
-            
-            file_info = {
-                "name": os.path.basename(filename),
-                "path": filename,
-                "mime_type": self.get_mime_type(filename),
-                "size": os.path.getsize(filename)
-            }
-            
-            archive_text = self.add_to_archive(file_info)
-            return file_info, archive_text
-            
-        except Exception as e:
-            error_msg = f"فشل التحميل باستخدام yt-dlp: {str(e)}"
-            raise gr.Error(error_msg)
-
-    async def get_session_token(self, url):
-        """الحصول على توكن الجلسة"""
-        try:
-            # Parse URL and get base domain
-            parsed = urlparse(url)
-            base_url = f"{parsed.scheme}://{parsed.netloc}"
-            
-            # Setup session with browser-like headers
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
-                'Accept-Language': 'en-US,en;q=0.9',
-                'Accept-Encoding': 'gzip, deflate, br',
-                'Connection': 'keep-alive',
-                'Upgrade-Insecure-Requests': '1',
-                'Sec-Fetch-Dest': 'document',
-                'Sec-Fetch-Mode': 'navigate',
-                'Sec-Fetch-Site': 'none',
-                'Sec-Fetch-User': '?1',
-                'Cache-Control': 'max-age=0',
-            }
-            
-            connector = aiohttp.TCPConnector(ssl=False)
-            timeout = aiohttp.ClientTimeout(total=30)
-            
-            async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
-                # First get the main page to get initial cookies
-                async with session.get(base_url, headers=headers) as response:
-                    if response.status != 200:
-                        return None, None
-                    
-                    # Get cookies from response
-                    cookies = {k: v.value for k, v in response.cookies.items()}
-                    
-                    # Extract any session or token information from the response
-                    text = await response.text()
-                    token_patterns = [
-                        r'token["\']?\s*:\s*["\']([^"\']+)["\']',
-                        r'auth["\']?\s*:\s*["\']([^"\']+)["\']',
-                        r'session["\']?\s*:\s*["\']([^"\']+)["\']',
-                    ]
-                    
-                    session_token = None
-                    for pattern in token_patterns:
-                        match = re.search(pattern, text, re.IGNORECASE)
-                        if match:
-                            session_token = match.group(1)
-                            break
-                    
-                    return cookies, session_token
-            
-        except Exception as e:
-            print(f"Error getting session token: {str(e)}")
-            return None, None
-
-    async def refresh_video_token(self, url):
-        """تحديث توكن الفيديو"""
-        try:
-            parsed = urlparse(url)
-            query_params = parse_qs(parsed.query)
-            
-            # Get current timestamp
-            current_time = int(time.time())
-            
-            # Generate new token parameters
-            new_params = {
-                't': query_params.get('t', [''])[0],
-                's': str(current_time),
-                'e': '86400',
-                'f': query_params.get('f', [''])[0],
-                'sp': query_params.get('sp', ['1000'])[0],
-                'i': '0.0',
-                '_': str(current_time * 1000)  # Add millisecond timestamp
-            }
-            
-            # Add any additional parameters from original URL
-            for k, v in query_params.items():
-                if k not in new_params and k not in ['s', 'e', '_']:
-                    new_params[k] = v[0]
-            
-            # Reconstruct URL with new parameters
-            base_url = f"{parsed.scheme}://{parsed.netloc}{parsed.path}"
-            new_url = f"{base_url}?{urlencode(new_params)}"
-            
-            return new_url
-            
-        except Exception as e:
-            print(f"Error refreshing token: {str(e)}")
-            return url
-
-    async def stream_download(self, url, output_path, headers=None, proxy=None):
-        """تنزيل الملف باستخدام التدفق"""
-        if not headers:
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-                'Accept': '*/*',
-                'Accept-Language': 'en-US,en;q=0.9',
-                'Accept-Encoding': 'gzip, deflate, br',
-                'Range': 'bytes=0-',
-                'Connection': 'keep-alive',
-                'Sec-Fetch-Dest': 'video',
-                'Sec-Fetch-Mode': 'cors',
-                'Sec-Fetch-Site': 'cross-site',
-                'Pragma': 'no-cache',
-                'Cache-Control': 'no-cache',
-            }
-
-        # Get session token and cookies
-        cookies, session_token = await self.get_session_token(url)
-        if cookies:
-            cookie_string = "; ".join([f"{k}={v}" for k, v in cookies.items()])
-            headers['Cookie'] = cookie_string
-        
-        if session_token:
-            headers['Authorization'] = f'Bearer {session_token}'
-
-        # Add referer and origin from the URL
-        parsed_url = urlparse(url)
-        base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
-        headers['Referer'] = base_url
-        headers['Origin'] = base_url
-
-        connector = aiohttp.TCPConnector(ssl=False, limit=1)
-        timeout = aiohttp.ClientTimeout(total=3600, connect=60)
-        
-        async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
-            try:
-                # First try HEAD request
-                async with session.head(url, headers=headers, proxy=proxy, allow_redirects=True) as response:
-                    if response.status == 403:
-                        # If 403, try refreshing the URL token
-                        url = await self.refresh_video_token(url)
-                        # Add updated timestamp to headers
-                        headers['X-Requested-With'] = 'XMLHttpRequest'
-                        headers['If-Modified-Since'] = time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime())
-                    total_size = int(response.headers.get('Content-Length', 0))
-            except Exception:
-                total_size = 0
-
-            # Prepare for chunked download
-            chunk_size = 1024 * 1024  # 1MB chunks
-            downloaded_size = 0
-            retries = 3
-            
-            while retries > 0:
-                try:
-                    async with session.get(url, headers=headers, proxy=proxy, allow_redirects=True) as response:
-                        if response.status == 403 and retries > 1:
-                            # Try refreshing token and retry
-                            url = await self.refresh_video_token(url)
-                            retries -= 1
-                            continue
-                            
-                        if response.status != 200:
-                            raise aiohttp.ClientError(f"HTTP {response.status}")
-                        
-                        with open(output_path, 'wb') as f:
-                            async for chunk in response.content.iter_chunked(chunk_size):
-                                if chunk:
-                                    f.write(chunk)
-                                    downloaded_size += len(chunk)
-                                    
-                                    # Update progress
-                                    if total_size:
-                                        progress = (downloaded_size / total_size) * 100
-                                        print(f"\rDownloading: {progress:.1f}%", end="")
-                        break
-                except Exception as e:
-                    print(f"Download attempt failed: {str(e)}")
-                    retries -= 1
-                    if retries == 0:
-                        raise
-                    await asyncio.sleep(2)
-
-    async def try_download(self, url, browser_cookies=None, proxy=None):
-        """محاولة تحميل الملف"""
-        temp_dir = tempfile.mkdtemp()
-        output_path = os.path.join(temp_dir, "video.mp4")
-        
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Accept': '*/*',
-            'Accept-Language': 'en-US,en;q=0.9',
-            'Accept-Encoding': 'gzip, deflate, br',
-            'Range': 'bytes=0-',
-            'Connection': 'keep-alive',
-            'Sec-Fetch-Dest': 'video',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'cross-site',
-            'Pragma': 'no-cache',
-            'Cache-Control': 'no-cache',
-        }
-        
-        # Add cookies to headers
-        if browser_cookies:
-            cookie_string = "; ".join([f"{k}={v}" for k, v in browser_cookies.items()])
-            headers['Cookie'] = cookie_string
-            
-        try:
-            await self.stream_download(url, output_path, headers, proxy)
-            
-            if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
-                file_info = {
-                    "name": os.path.basename(output_path),
-                    "path": output_path,
-                    "mime_type": self.get_mime_type(output_path),
-                    "size": os.path.getsize(output_path)
-                }
-                return file_info
-                
-        except Exception as e:
-            print(f"Download failed: {str(e)}")
-            if os.path.exists(output_path):
-                os.remove(output_path)
-            
-        return None
-
-    async def download_file(self, url):
-        """تحميل الملف"""
-        try:
-            # Get cookies
-            browser_cookies = self.get_cookies(url)
-            
-            # First try direct download
-            result = await self.try_download(url, browser_cookies)
-            if result:
-                archive_text = self.add_to_archive(result)
-                return result, archive_text
-            
-            # If direct fails, try with proxies
-            max_retries = 3
-            for i in range(max_retries):
-                proxy = self.get_random_proxy()
-                if not proxy:
-                    continue
-                    
-                try:
-                    result = await self.try_download(url, browser_cookies, proxy)
-                    if result:
-                        archive_text = self.add_to_archive(result)
-                        return result, archive_text
-                except Exception as e:
-                    print(f"Proxy attempt {i+1} failed: {str(e)}")
-                    continue
-            
-            # If all attempts fail, try yt-dlp as last resort
-            return await self.download_with_ytdlp(url, browser_cookies, use_proxy=True)
-            
-        except Exception as e:
-            error_msg = f"حدث خطأ في التحميل: {str(e)}"
-            raise gr.Error(error_msg)
+        self.chunk_size = 1024 * 1024 * 5  # 5MB chunks
+        self.max_workers = 5  # عدد العمليات المتزامنة
 
     def get_filename_from_url(self, url, headers=None):
         try:
             if headers and 'content-disposition' in headers:
+                import re
                 matches = re.findall('filename="(.+)"', headers['content-disposition'])
                 if matches:
                     return matches[0]
             
             path = urlparse(url).path
             filename = os.path.basename(path)
-            filename = filename.split('?')[0]
-            filename = filename.replace('[', '').replace(']', '')
-            if not filename or filename == '':
-                return 'downloaded_file'
-            return filename
+            return filename if filename else 'downloaded_file'
         except:
             return 'downloaded_file'
 
@@ -648,199 +39,95 @@ class FastDownloader:
         mime_type, _ = mimetypes.guess_type(filename)
         return mime_type or 'application/octet-stream'
 
-    def load_archive(self):
-        try:
-            if os.path.exists(self.archive_file):
-                with open(self.archive_file, 'r', encoding='utf-8') as f:
-                    self.archive = json.load(f)
-            else:
-                self.archive = []
-        except:
-            self.archive = []
-
-    def save_archive(self):
-        with open(self.archive_file, 'w', encoding='utf-8') as f:
-            json.dump(self.archive, f, ensure_ascii=False, indent=2)
-
-    def add_to_archive(self, file_info):
-        archive_entry = {
-            "name": file_info["name"],
-            "path": file_info["path"],
-            "size": file_info["size"],
-            "mime_type": file_info["mime_type"],
-            "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        }
-        self.archive.insert(0, archive_entry)
-        self.save_archive()
-        return self.format_archive()
-
-    def format_archive(self):
-        archive_text = "📚 أرشيف التحميلات:\n\n"
-        for entry in self.archive:
-            size_mb = entry["size"] / (1024 * 1024)
-            archive_text += f"📥 {entry['name']}\n"
-            archive_text += f"   📅 {entry['date']}\n"
-            archive_text += f"   📦 {size_mb:.1f} MB\n"
-            archive_text += f"   📎 {entry['mime_type']}\n"
-            archive_text += "─" * 50 + "\n"
-        return archive_text
-
-    async def handle_successful_download(self, response):
-        """معالجة التحميل الناجح"""
-        filename = self.get_filename_from_url(response.url, dict(response.headers))
-        temp_dir = tempfile.mkdtemp()
-        file_path = os.path.join(temp_dir, filename)
-        
-        total_size = int(response.headers.get('content-length', 0))
-        chunk_size = 1024 * 1024  # 1MB chunks
-        
-        with open(file_path, 'wb') as f:
-            downloaded = 0
-            async for chunk in response.content.iter_chunked(chunk_size):
-                if chunk:
-                    f.write(chunk)
-                    downloaded += len(chunk)
-                    if total_size:
-                        progress = (downloaded / total_size) * 100
-                        print(f"\rDownloading: {progress:.1f}%", end="")
+    async def download_chunk(self, session, url, start, end, file, semaphore):
+        """تحميل جزء من الملف"""
+        headers = {'Range': f'bytes={start}-{end}'}
         
-        file_info = {
-            "name": filename,
-            "path": file_path,
-            "mime_type": self.get_mime_type(filename),
-            "size": os.path.getsize(file_path)
-        }
-        
-        archive_text = self.add_to_archive(file_info)
-        return file_info, archive_text
-
-    async def get_m3u8_segments(self, url):
-        """Get HLS segments from m3u8 playlist"""
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Accept': '*/*',
-            'Accept-Language': 'en-US,en;q=0.9',
-            'Accept-Encoding': 'gzip, deflate, br',
-            'Origin': 'https://cdn-tube.xyz',
-            'Sec-Fetch-Site': 'cross-site',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Dest': 'empty',
-            'Referer': 'https://cdn-tube.xyz/',
-        }
+        async with semaphore:
+            try:
+                async with session.get(url, headers=headers) as response:
+                    response.raise_for_status()
+                    chunk = await response.read()
+                    with open(file, 'r+b') as f:
+                        f.seek(start)
+                        f.write(chunk)
+                    return len(chunk)
+            except Exception as e:
+                print(f"Error downloading chunk {start}-{end}: {str(e)}")
+                return 0
 
+    async def download_file(self, url):
+        """تحميل الملف بشكل متزامن"""
         try:
-            # Convert direct video URL to m3u8 URL if needed
-            if not url.endswith('.m3u8'):
-                parsed = urlparse(url)
-                path_parts = parsed.path.split('/')
-                if len(path_parts) > 1:
-                    video_id = path_parts[-2]
-                    m3u8_url = f"{parsed.scheme}://{parsed.netloc}/hls/{video_id}/index.m3u8"
-                    # Add original query parameters
-                    m3u8_url += '?' + parsed.query if parsed.query else ''
-                else:
-                    return None
-
+            # إنشاء جلسة HTTP
             async with aiohttp.ClientSession() as session:
-                async with session.get(m3u8_url, headers=headers) as response:
-                    if response.status != 200:
-                        return None
-                    
-                    m3u8_content = await response.text()
-                    
-                    # Parse m3u8 content
-                    segments = []
-                    base_url = m3u8_url.rsplit('/', 1)[0] + '/'
-                    
-                    for line in m3u8_content.splitlines():
-                        if line.endswith('.ts'):
-                            if line.startswith('http'):
-                                segments.append(line)
-                            else:
-                                segments.append(base_url + line)
-                    
-                    return segments
-        except Exception as e:
-            print(f"Error getting m3u8 segments: {str(e)}")
-            return None
+                # الحصول على معلومات الملف
+                async with session.head(url) as response:
+                    response.raise_for_status()
+                    total_size = int(response.headers.get('content-length', 0))
+                    filename = self.get_filename_from_url(url, response.headers)
 
-    async def download_with_segments(self, url, output_path):
-        """Download video using HLS segments"""
-        segments = await self.get_m3u8_segments(url)
-        if not segments:
-            return False
+                if total_size == 0:
+                    raise gr.Error("لا يمكن تحديد حجم الملف")
 
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Accept': '*/*',
-            'Accept-Language': 'en-US,en;q=0.9',
-            'Accept-Encoding': 'gzip, deflate, br',
-            'Origin': 'https://cdn-tube.xyz',
-            'Sec-Fetch-Site': 'cross-site',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Dest': 'empty',
-            'Referer': 'https://cdn-tube.xyz/',
-        }
+                # إنشاء ملف مؤقت
+                temp_dir = tempfile.mkdtemp()
+                file_path = os.path.join(temp_dir, filename)
 
-        total_segments = len(segments)
-        downloaded_segments = 0
+                # تحديد حجم كل جزء
+                chunk_size = math.ceil(total_size / self.max_workers)
+                
+                # إنشاء الملف بالحجم المطلوب
+                with open(file_path, 'wb') as f:
+                    f.seek(total_size - 1)
+                    f.write(b'\0')
+
+                # إنشاء مهام التحميل
+                semaphore = asyncio.Semaphore(self.max_workers)
+                tasks = []
+                
+                for i in range(self.max_workers):
+                    start = i * chunk_size
+                    end = min(start + chunk_size - 1, total_size - 1)
+                    task = self.download_chunk(session, url, start, end, file_path, semaphore)
+                    tasks.append(task)
+
+                # تنفيذ المهام بشكل متزامن
+                await asyncio.gather(*tasks)
+
+                return {
+                    "name": filename,
+                    "path": file_path,
+                    "mime_type": self.get_mime_type(filename),
+                    "size": os.path.getsize(file_path)
+                }
 
-        try:
-            with open(output_path, 'wb') as outfile:
-                async with aiohttp.ClientSession() as session:
-                    for segment_url in segments:
-                        retries = 3
-                        while retries > 0:
-                            try:
-                                async with session.get(segment_url, headers=headers) as response:
-                                    if response.status == 200:
-                                        chunk = await response.read()
-                                        outfile.write(chunk)
-                                        downloaded_segments += 1
-                                        progress = (downloaded_segments / total_segments) * 100
-                                        print(f"\rDownloading: {progress:.1f}%", end="")
-                                        break
-                                    elif response.status == 403:
-                                        # Try refreshing token
-                                        segment_url = await self.refresh_video_token(segment_url)
-                                        retries -= 1
-                                        await asyncio.sleep(1)
-                                        continue
-                                    else:
-                                        retries -= 1
-                            except Exception:
-                                retries -= 1
-                                await asyncio.sleep(1)
-                                
-                            if retries == 0:
-                                print(f"\nFailed to download segment: {segment_url}")
-                                return False
-                            
-            return True
         except Exception as e:
-            print(f"Error downloading segments: {str(e)}")
-            return False
-
-    async def try_download(self, url, browser_cookies=None, proxy=None):
-        """محاولة تحميل الملف"""
-        temp_dir = tempfile.mkdtemp()
-        output_path = os.path.join(temp_dir, "video.mp4")
-
-        # Try HLS download first
-        if await self.download_with_segments(url, output_path):
-            return output_path, temp_dir
+            raise gr.Error(f"حدث خطأ في التحميل: {str(e)}")
 
-        # If HLS fails, try direct download
+    def download_youtube(self, url):
+        """تحميل فيديو يوتيوب"""
         try:
-            await self.stream_download(url, output_path, proxy=proxy)
-            return output_path, temp_dir
+            temp_dir = tempfile.mkdtemp()
+            
+            opts = dict(self.ydl_opts)
+            opts.update({
+                'outtmpl': os.path.join(temp_dir, '%(title)s.%(ext)s'),
+            })
+            
+            with yt_dlp.YoutubeDL(opts) as ydl:
+                info = ydl.extract_info(url, download=True)
+                filename = ydl.prepare_filename(info)
+            
+            return {
+                "name": os.path.basename(filename),
+                "path": filename,
+                "mime_type": self.get_mime_type(filename),
+                "size": os.path.getsize(filename)
+            }
+
         except Exception as e:
-            # If both methods fail, try yt-dlp
-            try:
-                await self.download_with_ytdlp(url, output_path)
-                return output_path, temp_dir
-            except Exception as ytdlp_error:
-                raise Exception(f"All download methods failed. Last error: {str(ytdlp_error)}")
+            raise gr.Error(f"حدث خطأ في تحميل الفيديو: {str(e)}")
 
 def create_interface():
     downloader = FastDownloader()
@@ -868,40 +155,32 @@ def create_interface():
         with gr.Row():
             status = gr.Textbox(label="الحالة", value="جاهز للتحميل", interactive=False)
             file_output = gr.File(label="الملف المحمل")
-            
-        with gr.Row():
-            archive = gr.Textbox(
-                label="أرشيف التحميلات",
-                value=downloader.format_archive(),
-                interactive=False,
-                lines=10
-            )
         
         def download_and_update(url):
             if not url:
-                return "الرجاء إدخال رابط صحيح", None, downloader.format_archive()
+                return "الرجاء إدخال رابط صحيح", None
             
             try:
                 domain = urlparse(url).netloc
                 
                 if 'youtube.com' in domain or 'youtu.be' in domain:
-                    file_info, archive_text = downloader.download_youtube(url)
+                    file_info = downloader.download_youtube(url)
                 else:
+                    # استخدام asyncio للتحميل المتزامن
                     loop = asyncio.new_event_loop()
                     asyncio.set_event_loop(loop)
-                    file_info, archive_text = loop.run_until_complete(downloader.download_file(url))
+                    file_info = loop.run_until_complete(downloader.download_file(url))
                     loop.close()
                 
-                return "تم التحميل بنجاح!", file_info["path"], archive_text
+                return "تم التحميل بنجاح!", file_info["path"]
                 
             except Exception as e:
-                error_msg = f"حدث خطأ: {str(e)}"
-                raise gr.Error(error_msg)
+                return f"حدث خطأ: {str(e)}", None
         
         download_btn.click(
             fn=download_and_update,
             inputs=url_input,
-            outputs=[status, file_output, archive]
+            outputs=[status, file_output]
         )
     
     return demo

requirements.txt

@@ -1,9 +1,5 @@
 gradio>=4.7.1
 yt-dlp>=2023.12.30
 aiohttp>=3.9.1
-selenium>=4.16.0
-undetected-chromedriver>=3.5.4
-beautifulsoup4>=4.12.2
-urllib3<2.0.0
-aiohttp-proxy>=0.1.2
-fake-useragent>=1.4.0
+requests>=2.31.0
+pytube>=15.0.0