Update app.py

app.py

@@ -14,127 +14,13 @@ import traceback
 import json
 from typing import List, Tuple, Optional, Dict
 import requests
-import threading
-import time
-from datetime import datetime, timedelta
-import queue
+import asyncio
 import concurrent.futures
-from functools import wraps
-import atexit
-
-# Configuration for TalkGPT upload
-TALKGPT_API_URL = "https://talkgpt.ir/api/LUMA/upload.php"
-TALKGPT_API_KEY = os.getenv("TALKGPT_API_KEY", "YOUR_STRONG_SECRET_API_KEY_12345")
-
-# Clean up old files every hour
-CLEANUP_INTERVAL = 3600  # 1 hour
-FILE_MAX_AGE = 86400  # 24 hours
-
-# Track created files
-created_files = queue.Queue()
-created_files_lock = threading.Lock()
-
-# Executor for concurrent processing
-executor = concurrent.futures.ThreadPoolExecutor(max_workers=5)
-
-def cleanup_old_files():
-    """Clean up files older than 24 hours"""
-    while True:
-        try:
-            current_time = time.time()
-            temp_dir = tempfile.gettempdir()
-            
-            # Clean temp directory
-            for item in os.listdir(temp_dir):
-                item_path = os.path.join(temp_dir, item)
-                try:
-                    if os.path.isfile(item_path):
-                        if current_time - os.path.getmtime(item_path) > FILE_MAX_AGE:
-                            os.unlink(item_path)
-                            print(f"Deleted old file: {item_path}")
-                    elif os.path.isdir(item_path) and item.startswith(('tmp', 'url_downloads_')):
-                        if current_time - os.path.getmtime(item_path) > FILE_MAX_AGE:
-                            shutil.rmtree(item_path)
-                            print(f"Deleted old directory: {item_path}")
-                except Exception as e:
-                    print(f"Error cleaning {item_path}: {e}")
-            
-            # Clean tracked files
-            cleaned_files = []
-            with created_files_lock:
-                while not created_files.empty():
-                    file_info = created_files.get()
-                    if current_time - file_info['time'] > FILE_MAX_AGE:
-                        try:
-                            if os.path.exists(file_info['path']):
-                                if os.path.isfile(file_info['path']):
-                                    os.unlink(file_info['path'])
-                                elif os.path.isdir(file_info['path']):
-                                    shutil.rmtree(file_info['path'])
-                                print(f"Deleted tracked file: {file_info['path']}")
-                        except Exception as e:
-                            print(f"Error deleting tracked file {file_info['path']}: {e}")
-                    else:
-                        cleaned_files.append(file_info)
-                
-                # Put back files that are not old enough
-                for file_info in cleaned_files:
-                    created_files.put(file_info)
-            
-        except Exception as e:
-            print(f"Cleanup error: {e}")
-        
-        time.sleep(CLEANUP_INTERVAL)
-
-# Start cleanup thread
-cleanup_thread = threading.Thread(target=cleanup_old_files, daemon=True)
-cleanup_thread.start()
-
-def track_file(file_path):
-    """Track a created file for cleanup"""
-    with created_files_lock:
-        created_files.put({
-            'path': file_path,
-            'time': time.time()
-        })
-
-def upload_to_talkgpt(file_path):
-    """Upload file to TalkGPT and return the URL"""
-    try:
-        if not os.path.exists(file_path):
-            return None, "File not found"
-        
-        with open(file_path, 'rb') as f:
-            files = {'file': (os.path.basename(file_path), f)}
-            data = {'api_key': TALKGPT_API_KEY}
-            headers = {'X-API-KEY': TALKGPT_API_KEY}
-            
-            response = requests.post(
-                TALKGPT_API_URL,
-                files=files,
-                data=data,
-                headers=headers,
-                timeout=300  # 5 minutes timeout for large files
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                if result.get('success'):
-                    file_url = result.get('file_url')
-                    expiry = result.get('expiry_timestamp', time.time() + 86400)
-                    expiry_date = datetime.fromtimestamp(expiry).strftime('%Y-%m-%d %H:%M:%S')
-                    return file_url, f"Expires: {expiry_date}"
-                else:
-                    return None, result.get('message', 'Upload failed')
-            else:
-                return None, f"HTTP {response.status_code}: {response.text}"
-    
-    except requests.exceptions.Timeout:
-        return None, "Upload timeout - file may be too large"
-    except Exception as e:
-        return None, f"Upload error: {str(e)}"
+from datetime import datetime
+import threading
+import queue as queue_module
 
-# Clean up any existing temp files on startup
+# Clean up any existing temp files on startup to save space
 try:
     tempdir = tempfile.gettempdir()
     for item in os.listdir(tempdir):
@@ -166,6 +52,14 @@ client = openai.OpenAI(
 
 MODEL_NAME = "x-ai/grok-4-fast"
 
+# Thread pool for concurrent execution
+MAX_WORKERS = 5  # تعداد همزمانی را می‌توانید تنظیم کنید
+executor = concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS)
+
+# Track active requests
+active_requests = {}
+request_lock = threading.Lock()
+
 class ErrorAnalyzer:
     """Analyze errors and suggest fixes"""
     
@@ -380,48 +274,52 @@ def detect_required_packages(code):
     
     return list(required_packages)
 
+# Package installation lock to prevent concurrent pip operations
+pip_lock = threading.Lock()
+
 def install_package(package_name):
     """Install a package using pip if it's not already installed."""
-    try:
-        # Special handling for some packages
-        import_name = package_name
-        if package_name == 'opencv-python':
-            import_name = 'cv2'
-        elif package_name == 'scikit-learn':
-            import_name = 'sklearn'
-        elif package_name == 'pillow' or package_name == 'Pillow':
-            import_name = 'PIL'
-        elif package_name == 'beautifulsoup4':
-            import_name = 'bs4'
-        elif package_name == 'psycopg2-binary':
-            import_name = 'psycopg2'
-        else:
-            import_name = package_name.replace('-', '_')
-            
-        spec = importlib.util.find_spec(import_name)
-        if spec is None:
-            print(f"Installing package: {package_name}")
-            result = subprocess.run([
-                sys.executable, "-m", "pip", "install", "--quiet", "--no-cache-dir", package_name
-            ], capture_output=True, text=True)
-            
-            if result.returncode == 0:
-                print(f"✅ {package_name} installed successfully.")
-                return True
+    with pip_lock:  # Prevent concurrent pip operations
+        try:
+            # Special handling for some packages
+            import_name = package_name
+            if package_name == 'opencv-python':
+                import_name = 'cv2'
+            elif package_name == 'scikit-learn':
+                import_name = 'sklearn'
+            elif package_name == 'pillow' or package_name == 'Pillow':
+                import_name = 'PIL'
+            elif package_name == 'beautifulsoup4':
+                import_name = 'bs4'
+            elif package_name == 'psycopg2-binary':
+                import_name = 'psycopg2'
             else:
-                print(f"❌ Failed to install {package_name}: {result.stderr}")
-                return False
-        else:
-            print(f"✅ {package_name} already installed.")
-            return True
-    except Exception as e:
-        print(f"❌ Error checking/installing {package_name}: {str(e)}")
-        return False
+                import_name = package_name.replace('-', '_')
+                
+            spec = importlib.util.find_spec(import_name)
+            if spec is None:
+                print(f"[Thread {threading.current_thread().name}] Installing package: {package_name}")
+                result = subprocess.run([
+                    sys.executable, "-m", "pip", "install", "--quiet", "--no-cache-dir", package_name
+                ], capture_output=True, text=True)
+                
+                if result.returncode == 0:
+                    print(f"[Thread {threading.current_thread().name}] ✅ {package_name} installed successfully.")
+                    return True
+                else:
+                    print(f"[Thread {threading.current_thread().name}] ❌ Failed to install {package_name}: {result.stderr}")
+                    return False
+            else:
+                print(f"[Thread {threading.current_thread().name}] ✅ {package_name} already installed.")
+                return True
+        except Exception as e:
+            print(f"[Thread {threading.current_thread().name}] ❌ Error checking/installing {package_name}: {str(e)}")
+            return False
 
 def install_packages_if_needed(packages):
     """Install required packages."""
     if not packages:
-        print("No additional packages to install.")
+        print(f"[Thread {threading.current_thread().name}] No additional packages to install.")
         return True
     
     success_count = 0
@@ -434,10 +332,10 @@ def install_packages_if_needed(packages):
             else:
                 failed_packages.append(package)
     
-    print(f"✅ Installed/checked {success_count}/{len(packages)} packages.")
+    print(f"[Thread {threading.current_thread().name}] ✅ Installed/checked {success_count}/{len(packages)} packages.")
     
     if failed_packages:
-        print(f"⚠️ Failed to install: {', '.join(failed_packages)}")
+        print(f"[Thread {threading.current_thread().name}] ⚠️ Failed to install: {', '.join(failed_packages)}")
     
     return len(failed_packages) == 0
 
@@ -456,11 +354,10 @@ def download_file_from_url(url: str, temp_dir: str) -> Optional[str]:
             for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
         
-        print(f"Downloaded {url} to {local_path}")
-        track_file(local_path)
+        print(f"[Thread {threading.current_thread().name}] Downloaded {url} to {local_path}")
         return local_path
     except Exception as e:
-        print(f"Failed to download {url}: {e}")
+        print(f"[Thread {threading.current_thread().name}] Failed to download {url}: {e}")
         return None
 
 def generate_code_with_openrouter(instruction, file_paths, previous_errors=None, attempt=1):
@@ -574,7 +471,7 @@ Output ONLY Python code, no markdown.
         
     except Exception as api_error:
         error_msg = f"API Error: {api_error}"
-        print(error_msg)
+        print(f"[Thread {threading.current_thread().name}] {error_msg}")
         # Return simple fallback
         return """import sys
 print("OUTPUT_TEXT: Code generation failed due to API error")
@@ -582,18 +479,19 @@ sys.exit(0)"""
 
 def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str, Optional[str]]:
     """Execute code with retry logic and error recovery"""
+    thread_name = threading.current_thread().name
     tf_path = None
     attempt = 0
     
     while attempt < max_attempts:
         attempt += 1
-        print(f"\n=== Execution attempt {attempt}/{max_attempts} ===")
+        print(f"\n[Thread {thread_name}] === Execution attempt {attempt}/{max_attempts} ===")
         
         try:
             # Step 1: Detect and install packages
-            print("Detecting packages...")
+            print(f"[Thread {thread_name}] Detecting packages...")
             required_packages = detect_required_packages(code)
-            print("Detected packages:", required_packages)
+            print(f"[Thread {thread_name}] Detected packages:", required_packages)
             install_packages_if_needed(required_packages)
             
             # Step 2: Wrap code
@@ -601,28 +499,27 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
             wrapped_code = f"try:\n{indented}\nexcept Exception as e:\n    print(f'ERROR: {{e}}')\n    import traceback; traceback.print_exc()\n    import sys; sys.exit(1)"
             
             # Step 3: Compile check
-            print("Compiling code...")
+            print(f"[Thread {thread_name}] Compiling code...")
             try:
                 compile(wrapped_code, '<string>', 'exec')
-                print("Compile OK.")
+                print(f"[Thread {thread_name}] Compile OK.")
             except SyntaxError as se:
                 error_msg = f"Syntax Error: {se}"
                 if attempt < max_attempts:
-                    print(f"Syntax error on attempt {attempt}, will regenerate code")
+                    print(f"[Thread {thread_name}] Syntax error on attempt {attempt}, will regenerate code")
                     return False, error_msg, None
                 else:
                     return False, error_msg, None
             
             # Step 4: Create temp file
-            print("Creating temp file...")
+            print(f"[Thread {thread_name}] Creating temp file...")
             with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as tf:
                 tf.write(wrapped_code)
                 tf_path = tf.name
-            print(f"Temp file: {tf_path}")
-            track_file(tf_path)
+            print(f"[Thread {thread_name}] Temp file: {tf_path}")
             
             # Step 5: Execute
-            print(f"Executing...")
+            print(f"[Thread {thread_name}] Executing...")
             result = subprocess.run(
                 [sys.executable, tf_path],
                 capture_output=True,
@@ -641,7 +538,7 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
             
             if rc != 0:
                 error_msg = f"Execution failed (RC {rc}):\nStderr: {stderr}"
-                print(error_msg)
+                print(f"[Thread {thread_name}] {error_msg}")
                 
                 # Check if we should retry
                 if attempt < max_attempts:
@@ -650,7 +547,7 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
                     
                     # Try to fix by installing missing packages
                     if error_analysis['packages']:
-                        print(f"Attempting to install missing packages: {error_analysis['packages']}")
+                        print(f"[Thread {thread_name}] Attempting to install missing packages: {error_analysis['packages']}")
                         for pkg in error_analysis['packages']:
                             install_package(pkg)
                     
@@ -665,12 +562,11 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
             if output_path_match:
                 output_path = output_path_match.group(1).strip()
                 if os.path.exists(output_path):
-                    track_file(output_path)
                     return True, stdout, output_path
                 else:
                     error_msg = f"Output path not found: {output_path}"
                     if attempt < max_attempts:
-                        print(error_msg)
+                        print(f"[Thread {thread_name}] {error_msg}")
                         return False, error_msg, None
                     else:
                         return False, error_msg, None
@@ -685,25 +581,28 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
         except subprocess.TimeoutExpired:
             error_msg = "Timeout: Code execution took too long"
             if attempt < max_attempts:
-                print(error_msg)
+                print(f"[Thread {thread_name}] {error_msg}")
                 return False, error_msg, None
             else:
                 return False, error_msg, None
         except Exception as e:
             error_msg = f"Execution error: {str(e)}"
             if attempt < max_attempts:
-                print(error_msg)
+                print(f"[Thread {thread_name}] {error_msg}")
                 return False, error_msg, None
             else:
                 return False, error_msg, None
     
     return False, "Max attempts reached", None
 
-def process_request_sync(instruction, files, urls_input):
-    """Synchronous processing function"""
+def process_request_sync(instruction, files, urls_input, request_id):
+    """Synchronous processing function that will be run in thread pool."""
+    thread_name = threading.current_thread().name
+    print(f"\n[Thread {thread_name}] Starting request {request_id}")
+    
     try:
         if not instruction.strip():
-            return "لطفاً دستور را وارد کنید. (فایل‌ها و لینک‌ها اختیاری هستند)", None, None
+            return "لطفاً دستور را وارد کنید. (فایل‌ها و لینک‌ها اختیاری هستند)", None
         
         file_paths = []
         
@@ -714,7 +613,6 @@ def process_request_sync(instruction, files, urls_input):
         # Handle URLs: download to temp dir
         if urls_input and urls_input.strip():
             temp_dir_for_downloads = tempfile.mkdtemp(prefix='url_downloads_')
-            track_file(temp_dir_for_downloads)
             urls = [url.strip() for url in urls_input.split(',') if url.strip()]
             downloaded_paths = []
             for url in urls:
@@ -722,7 +620,7 @@ def process_request_sync(instruction, files, urls_input):
                 if local_path:
                     downloaded_paths.append(local_path)
             file_paths.extend(downloaded_paths)
-            print(f"Downloaded {len(downloaded_paths)} files from URLs")
+            print(f"[Thread {thread_name}] Downloaded {len(downloaded_paths)} files from URLs")
         
         # Track errors for learning
         previous_errors = []
@@ -730,12 +628,12 @@ def process_request_sync(instruction, files, urls_input):
         
         # Main retry loop
         for attempt in range(1, 4):  # 3 attempts
-            print(f"\n{'='*50}")
-            print(f"MAIN ATTEMPT {attempt}/3")
-            print(f"{'='*50}")
+            print(f"\n[Thread {thread_name}] {'='*50}")
+            print(f"[Thread {thread_name}] MAIN ATTEMPT {attempt}/3 for request {request_id}")
+            print(f"[Thread {thread_name}] {'='*50}")
             
             # Generate code
-            print("Generating code...")
+            print(f"[Thread {thread_name}] Generating code...")
             generated_code = generate_code_with_openrouter(
                 instruction, 
                 file_paths, 
@@ -744,43 +642,29 @@ def process_request_sync(instruction, files, urls_input):
             )
             
             if len(generated_code) < 20:
-                return f"کد ضعیف تولید شد: {generated_code}", None, None
+                return f"کد ضعیف تولید شد: {generated_code}", None
             
             generated_codes.append(generated_code)
-            print(f"Generated code preview: {generated_code[:200]}...")
+            print(f"[Thread {thread_name}] Generated code preview: {generated_code[:200]}...")
             
             # Try to execute
             success, output, file_path = execute_code_with_retry(generated_code, max_attempts=2)
             
             if success:
-                # Success! Upload to TalkGPT if file was generated
-                talkgpt_url = None
-                talkgpt_message = ""
-                if file_path and os.path.exists(file_path):
-                    print("Uploading to TalkGPT...")
-                    talkgpt_url, talkgpt_message = upload_to_talkgpt(file_path)
-                    if talkgpt_url:
-                        result_text = f"✅ Success on attempt {attempt}!\n\n"
-                        result_text += f"📁 TalkGPT URL: {talkgpt_url}\n"
-                        result_text += f"📅 {talkgpt_message}\n\n"
-                    else:
-                        result_text = f"✅ Success on attempt {attempt}!\n\n"
-                        result_text += f"⚠️ Upload to TalkGPT failed: {talkgpt_message}\n\n"
-                else:
-                    result_text = f"✅ Success on attempt {attempt}!\n\n"
-                
+                # Success!
+                result_text = f"✅ Success on attempt {attempt}!\n\n"
                 result_text += f"Generated Code:\n```python\n{generated_code}\n```\n\n"
                 result_text += f"Output:\n{output}"
-                
-                return result_text, file_path, talkgpt_url
+                print(f"[Thread {thread_name}] Request {request_id} completed successfully")
+                return result_text, file_path
             else:
                 # Analyze error
-                print(f"\n❌ Attempt {attempt} failed")
+                print(f"\n[Thread {thread_name}] ❌ Attempt {attempt} failed for request {request_id}")
                 error_analysis = ErrorAnalyzer.analyze_error(output, generated_code)
                 previous_errors.append(error_analysis)
                 
-                print(f"Error type: {error_analysis['error_type']}")
-                print(f"Suggestions: {', '.join(error_analysis['suggestions'])}")
+                print(f"[Thread {thread_name}] Error type: {error_analysis['error_type']}")
+                print(f"[Thread {thread_name}] Suggestions: {', '.join(error_analysis['suggestions'])}")
                 
                 # If this was the last attempt
                 if attempt == 3:
@@ -792,63 +676,66 @@ def process_request_sync(instruction, files, urls_input):
                         error_report += f"- Details: {err['original_error'][:200]}...\n"
                     
                     error_report += f"\n\nLast generated code:\n```python\n{generated_code}\n```"
-                    return error_report, None, None
+                    print(f"[Thread {thread_name}] Request {request_id} failed after all attempts")
+                    return error_report, None
         
-        return "Unexpected end of retry loop", None, None
+        return "Unexpected end of retry loop", None
         
     except Exception as e:
         error_msg = f"General error: {type(e).__name__}: {e}\nFull traceback: {traceback.format_exc()}"
-        print(error_msg)
-        return error_msg, None, None
-
-def process_request(instruction, files, urls_input):
-    """Process request with concurrent execution support"""
-    future = executor.submit(process_request_sync, instruction, files, urls_input)
-    result_text, file_path, talkgpt_url = future.result()
-    
-    # Return results with TalkGPT URL as the file output
-    # If there's a TalkGPT URL, return it as an HTML link
-    if talkgpt_url:
-        # Create an HTML component for the link
-        file_output_html = f"""{talkgpt_url}"""
-        return result_text, file_output_html
-    else:
-        # No file was generated or upload failed
-        return result_text, None
+        print(f"[Thread {thread_name}] {error_msg}")
+        return error_msg, None
 
-# Cleanup on exit
-def cleanup_on_exit():
-    """Clean up when the app exits"""
-    print("Cleaning up...")
-    executor.shutdown(wait=True)
-    # Final cleanup of tracked files
-    with created_files_lock:
-        while not created_files.empty():
-            file_info = created_files.get()
-            try:
-                if os.path.exists(file_info['path']):
-                    if os.path.isfile(file_info['path']):
-                        os.unlink(file_info['path'])
-                    elif os.path.isdir(file_info['path']):
-                        shutil.rmtree(file_info['path'])
-            except:
-                pass
-
-atexit.register(cleanup_on_exit)
+def process_request(instruction, files, urls_input, request):
+    """Async wrapper for Gradio that submits to thread pool."""
+    # Generate unique request ID
+    request_id = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{id(request)}"
+    
+    with request_lock:
+        active_count = len(active_requests)
+        if active_count >= MAX_WORKERS:
+            queue_position = active_count - MAX_WORKERS + 1
+            status_message = f"⏳ درخواست شما در صف است. موقعیت در صف: {queue_position}"
+            print(f"Request {request_id} queued. Position: {queue_position}")
+        else:
+            status_message = f"🚀 درخواست شما در حال پردازش است..."
+            print(f"Request {request_id} processing immediately")
+    
+    # Submit to thread pool
+    future = executor.submit(process_request_sync, instruction, files, urls_input, request_id)
+    
+    # Track request
+    with request_lock:
+        active_requests[request_id] = {
+            'future': future,
+            'start_time': datetime.now(),
+            'instruction': instruction[:100]  # Store first 100 chars
+        }
+    
+    # Wait for result
+    try:
+        result = future.result()  # This will block until complete
+    finally:
+        # Clean up
+        with request_lock:
+            if request_id in active_requests:
+                del active_requests[request_id]
+    
+    return result
 
-# Gradio Interface
-with gr.Blocks(title="AI File Processor - Self Correcting with TalkGPT Upload") as demo:
-    gr.Markdown("""
-    # 🤖 AI File Processor - Self Correcting Edition with TalkGPT Upload
+# Gradio Interface with queue enabled
+with gr.Blocks(title="AI File Processor - Concurrent") as demo:
+    gr.Markdown(f"""
+    # 🤖 AI File Processor - Concurrent Edition
+    
+    **🔥 قابلیت پردازش همزمان: تا {MAX_WORKERS} درخواست به صورت موازی**
     
     این سیستم می‌تواند:
     - کد Python تولید کند
     - خطاها را تشخیص و تحلیل کند
     - به طور خودکار مشکلات را برطرف کند
     - تا 3 بار با رویکردهای مختلف تلاش کند
-    - فایل‌های خروجی را به TalkGPT آپلود کند (لینک 7 روزه)
-    - چندین درخواست را همزمان پردازش کند
-    - فایل‌های قدیمی را به طور خودکار حذف کند (بعد از 24 ساعت)
+    - **چندین درخواست را همزمان پردازش کند**
     
     **مثال دستورات:**
     - "یک فایل اکسل با 1000 نام و شماره تلفن ایرانی بساز"
@@ -858,6 +745,14 @@ with gr.Blocks(title="AI File Processor - Self Correcting with TalkGPT Upload")
     **نکته:** می‌توانید فایل‌ها را آپلود کنید یا لینک‌های فایل را (جدا شده با کاما) وارد کنید.
     """)
     
+    # Status indicator
+    with gr.Row():
+        status_box = gr.Textbox(
+            label="وضعیت سیستم", 
+            value=f"✅ آماده دریافت درخواست | حداکثر {MAX_WORKERS} درخواست همزمان",
+            interactive=False
+        )
+    
     with gr.Row():
         instruction = gr.Textbox(
             label="دستور", 
@@ -878,7 +773,7 @@ with gr.Blocks(title="AI File Processor - Self Correcting with TalkGPT Upload")
     
     with gr.Row():
         output = gr.Textbox(label="نتیجه", lines=15)
-        file_link_output = gr.HTML(label="لینک دانلود فایل")
+        file_out = gr.File(label="فایل خروجی (در صورت تولید)")
     
     # Examples
     gr.Examples(
@@ -891,7 +786,34 @@ with gr.Blocks(title="AI File Processor - Self Correcting with TalkGPT Upload")
         inputs=[instruction, files, urls],
     )
     
-    btn.click(fn=process_request, inputs=[instruction, files, urls], outputs=[output, file_link_output])
+    # Update status periodically
+    def update_status():
+        with request_lock:
+            active_count = len(active_requests)
+            if active_count == 0:
+                return f"✅ آماده دریافت درخواست | حداکثر {MAX_WORKERS} درخواست همزمان"
+            elif active_count < MAX_WORKERS:
+                return f"🔄 {active_count} درخواست در حال پردازش | {MAX_WORKERS - active_count} جای خالی"
+            else:
+                return f"🔥 ظرفیت پر! {active_count} درخواست در حال پردازش | {active_count - MAX_WORKERS} در صف"
+    
+    # Enable queue for concurrent processing
+    btn.click(
+        fn=process_request, 
+        inputs=[instruction, files, urls], 
+        outputs=[output, file_out],
+        queue=True  # This enables queueing
+    )
+    
+    # Periodic status update (optional - you can remove if not needed)
+    demo.load(update_status, outputs=status_box, every=2)
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    # Launch with queue enabled for concurrent processing
+    demo.queue(
+        concurrency_count=MAX_WORKERS,  # Number of concurrent workers
+        max_size=100  # Maximum queue size
+    ).launch(
+        share=True,
+        max_threads=MAX_WORKERS * 2  # Allow more threads for handling requests
+    )