Update app.py

app.py

@@ -14,66 +14,127 @@ import traceback
 import json
 from typing import List, Tuple, Optional, Dict
 import requests
-import time # Added for cleanup
-
-# =================================================================
-# 1. Configuration and Setup
-# =================================================================
-
-# Use OpenRouter API (OpenAI-compatible)
-OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
-TALKGPT_API_KEY = os.getenv("TALKGPT_API_KEY", OPENROUTER_API_KEY) # Use OpenRouter key as fallback for TalkGPT
-TALKGPT_UPLOAD_URL = "https://talkgpt.ir/api/LUMA/upload.php"
-
-client = openai.OpenAI(
-    api_key=OPENROUTER_API_KEY,
-    base_url="https://openrouter.ai/api/v1"
-)
-
-MODEL_NAME = "x-ai/grok-4-fast"
-
-# Define a persistent directory for output files that need cleanup
-PERSISTENT_OUTPUT_DIR = os.path.join(tempfile.gettempdir(), "ai_processor_outputs")
-os.makedirs(PERSISTENT_OUTPUT_DIR, exist_ok=True)
+import threading
+import time
+from datetime import datetime, timedelta
+import queue
+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)
 
-# =================================================================
-# 3. Automatic Cleanup Function
-# =================================================================
+# Start cleanup thread
+cleanup_thread = threading.Thread(target=cleanup_old_files, daemon=True)
+cleanup_thread.start()
 
-def cleanup_old_files(directory: str, max_age_seconds: int = 86400):
-    """Removes files and directories older than max_age_seconds."""
-    now = time.time()
-    count = 0
-    
-    if not os.path.exists(directory):
-        return 0
+def track_file(file_path):
+    """Track a created file for cleanup"""
+    with created_files_lock:
+        created_files.put({
+            'path': file_path,
+            'time': time.time()
+        })
 
-    print(f"Starting cleanup in {directory} for items older than {max_age_seconds/3600:.1f} hours.")
-    
-    for item in os.listdir(directory):
-        item_path = os.path.join(directory, item)
-        try:
-            # Get modification time
-            mtime = os.path.getmtime(item_path)
-            if now - mtime > max_age_seconds:
-                if os.path.isfile(item_path):
-                    os.unlink(item_path)
-                    count += 1
-                elif os.path.isdir(item_path):
-                    shutil.rmtree(item_path)
-                    count += 1
-        except Exception as e:
-            # print(f"Error during cleanup of {item_path}: {e}")
-            pass
+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}
             
-    print(f"Cleanup finished. Removed {count} old items.")
-    return count
-
-# Clean up on startup
-cleanup_old_files(tempfile.gettempdir())
-cleanup_old_files(PERSISTENT_OUTPUT_DIR)
+            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)}"
 
-# Clean up any existing temp files on startup to save space (original logic kept)
+# Clean up any existing temp files on startup
 try:
     tempdir = tempfile.gettempdir()
     for item in os.listdir(tempdir):
@@ -96,79 +157,18 @@ try:
 except:
     pass
 
-# =================================================================
-# 2. TalkGPT Upload Function
-# =================================================================
-
-def upload_to_talkgpt(file_path: str) -> Optional[str]:
-    """Uploads a file to TalkGPT API and returns the public URL."""
-    if not TALKGPT_API_KEY:
-        print("TALKGPT_API_KEY is not set. Skipping upload.")
-        return None
-        
-    if not os.path.exists(file_path):
-        print(f"Error: File not found for upload: {file_path}")
-        return None
-
-    print(f"Attempting to upload file to TalkGPT: {os.path.basename(file_path)}")
-    
-    try:
-        # Prepare multipart/form-data
-        files = {
-            'file': (os.path.basename(file_path), open(file_path, 'rb'))
-        }
-        
-        # Prepare headers and data
-        headers = {
-            "X-API-KEY": TALKGPT_API_KEY
-        }
-        data = {
-            "api_key": TALKGPT_API_KEY
-        }
-
-        response = requests.post(
-            TALKGPT_UPLOAD_URL, 
-            files=files, 
-            data=data, 
-            headers=headers, 
-            timeout=60
-        )
-        
-        response.raise_for_status()
-        
-        # Parse JSON response
-        decoded = response.json()
-        
-        if decoded.get("success"):
-            file_url = decoded.get("file_url")
-            print(f"✅ Upload successful. URL: {file_url}")
-            return file_url
-        else:
-            message = decoded.get("message", "Unknown error during API response parsing")
-            print(f"❌ Upload failed. Message: {message}")
-            return None
-
-    except requests.exceptions.RequestException as e:
-        print(f"❌ Network/Request Error during upload: {e}")
-        return None
-    except json.JSONDecodeError:
-        print(f"❌ Failed to decode JSON response: {response.text}")
-        return None
-    except Exception as e:
-        print(f"❌ Unexpected error during upload: {e}")
-        return None
-    finally:
-        # Ensure file handle is closed
-        if 'file' in files:
-            files['file'][1].close()
+# Use OpenRouter API (OpenAI-compatible)
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+client = openai.OpenAI(
+    api_key=OPENROUTER_API_KEY,
+    base_url="https://openrouter.ai/api/v1"
+)
 
-# =================================================================
-# ErrorAnalyzer and Utility functions (No change needed)
-# =================================================================
+MODEL_NAME = "x-ai/grok-4-fast"
 
 class ErrorAnalyzer:
     """Analyze errors and suggest fixes"""
-    # ... (Keep the original ErrorAnalyzer class) ...
+    
     @staticmethod
     def analyze_error(error_message: str, code: str) -> Dict:
         """Analyze error and return fix strategy"""
@@ -267,7 +267,7 @@ def detect_required_packages(code):
     pre_installed = {
         'gradio', 'openai', 'pillow', 'rembg', 'numpy', 'opencv-python', 'scikit-learn',
         'tensorflow', 'torch', 'lxml', 'requests', 'matplotlib', 'seaborn', 'onnxruntime',
-        'proglog', 'openpyxl', 'moviepy', 'pandas' # Added pandas to pre-installed list for common usage
+        'proglog', 'openpyxl', 'moviepy'
     }
     
     # Import patterns
@@ -457,6 +457,7 @@ def download_file_from_url(url: str, temp_dir: str) -> Optional[str]:
                 f.write(chunk)
         
         print(f"Downloaded {url} to {local_path}")
+        track_file(local_path)
         return local_path
     except Exception as e:
         print(f"Failed to download {url}: {e}")
@@ -485,7 +486,6 @@ def generate_code_with_openrouter(instruction, file_paths, previous_errors=None,
             alternative_approaches += "\n- Implement fallback solutions"
             alternative_approaches += "\n- Generate mock data if files are problematic"
     
-    # NOTE: Instructing the model to save output to PERSISTENT_OUTPUT_DIR
     prompt_template = textwrap.dedent("""
 You are a Python expert. Instruction: "{instruction}"
 Input files: {file_paths_str} (use file_paths[0] for first file, iterate for multiple; if empty, generate based on instruction alone).
@@ -496,12 +496,11 @@ Write a complete Python script that:
 1. Import all necessary libraries at the top.
 2. Add "# pip install package_name" comments after imports for all needed libraries.
 3. Define file_paths = {file_paths_list}
-4. Define the output directory as PERSISTENT_OUTPUT_DIR = "{persistent_dir}"
-5. Add comprehensive error handling with try-except blocks
-6. Create output directory if needed using os.makedirs(PERSISTENT_OUTPUT_DIR, exist_ok=True)
-7. Save output to the PERSISTENT_OUTPUT_DIR
-8. Print "OUTPUT_FILE_PATH: /full/path/to/output" at the end using os.path.abspath()
-9. If file operations fail, try alternative approaches
+4. Add comprehensive error handling with try-except blocks
+5. Create output directory if needed using os.makedirs(exist_ok=True)
+6. Save output to a temp directory using tempfile.mkdtemp()
+7. Print "OUTPUT_FILE_PATH: /full/path/to/output" at the end using os.path.abspath()
+8. If file operations fail, try alternative approaches
 
 Important rules:
 - For pandas Excel operations, always add: # pip install openpyxl
@@ -515,8 +514,6 @@ Important rules:
 Example with error handling:
 import os
 import tempfile
-# Define the persistent output directory
-PERSISTENT_OUTPUT_DIR = "{persistent_dir}" 
 try:
     import pandas as pd
     # pip install pandas openpyxl
@@ -527,8 +524,9 @@ except ImportError:
 file_paths = {file_paths_list}
 
 try:
-    os.makedirs(PERSISTENT_OUTPUT_DIR, exist_ok=True)
-    output_path = os.path.join(PERSISTENT_OUTPUT_DIR, 'output.xlsx')
+    temp_dir = tempfile.mkdtemp()
+    os.makedirs(temp_dir, exist_ok=True)
+    output_path = os.path.join(temp_dir, 'output.xlsx')
     
     # Your main logic here with error handling
     
@@ -553,19 +551,18 @@ Output ONLY Python code, no markdown.
         file_paths_str=file_paths_str,
         file_paths_list=file_paths_list,
         error_context=error_context,
-        alternative_approaches=alternative_approaches,
-        persistent_dir=PERSISTENT_OUTPUT_DIR
+        alternative_approaches=alternative_approaches
     )
     
     try:
         response = client.chat.completions.create(
             model=MODEL_NAME,
             messages=[
-                {"role": "system", "content": "Output only clean executable Python code with comprehensive error handling. Ensure the output path is always inside PERSISTENT_OUTPUT_DIR."},
+                {"role": "system", "content": "Output only clean executable Python code with comprehensive error handling."},
                 {"role": "user", "content": prompt}
             ],
             max_tokens=4000,
-            temperature=0.1 if attempt == 1 else 0.3
+            temperature=0.1 if attempt == 1 else 0.3  # Increase creativity on retries
         )
         
         generated_code = response.choices[0].message.content.strip()
@@ -600,9 +597,8 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
             install_packages_if_needed(required_packages)
             
             # Step 2: Wrap code
-            # Note: We do not wrap the code in a generic try-except here because the model is instructed
-            # to include its own comprehensive try-except blocks, and we need the subprocess RC for failure analysis.
-            wrapped_code = code 
+            indented = indent_code(code)
+            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...")
@@ -623,15 +619,15 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
                 tf.write(wrapped_code)
                 tf_path = tf.name
             print(f"Temp file: {tf_path}")
+            track_file(tf_path)
             
             # Step 5: Execute
             print(f"Executing...")
-            # Use a short timeout for the execution itself
             result = subprocess.run(
                 [sys.executable, tf_path],
                 capture_output=True,
                 text=True,
-                timeout=90 # Increased timeout slightly for heavy processing
+                timeout=60
             )
             stdout, stderr = result.stdout, result.stderr
             rc = result.returncode
@@ -644,15 +640,13 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
                     pass
             
             if rc != 0:
-                # If RC is non-zero, it means the internal script failed, likely due to an unhandled exception
-                # or an explicit sys.exit(1) in the generated code's catch block.
-                error_msg = f"Execution failed (RC {rc}):\nStderr: {stderr}\nStdout: {stdout}"
+                error_msg = f"Execution failed (RC {rc}):\nStderr: {stderr}"
                 print(error_msg)
                 
                 # Check if we should retry
                 if attempt < max_attempts:
-                    # Analyze error for next attempt (use stderr for analysis)
-                    error_analysis = ErrorAnalyzer.analyze_error(stderr or stdout, code)
+                    # Analyze error for next attempt
+                    error_analysis = ErrorAnalyzer.analyze_error(stderr, code)
                     
                     # Try to fix by installing missing packages
                     if error_analysis['packages']:
@@ -660,7 +654,7 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
                         for pkg in error_analysis['packages']:
                             install_package(pkg)
                     
-                    return False, stderr or stdout, None
+                    return False, stderr, None
                 else:
                     return False, error_msg, None
             
@@ -670,11 +664,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()
-                # Ensure the path is within the allowed persistent directory
-                if os.path.exists(output_path) and os.path.abspath(output_path).startswith(os.path.abspath(PERSISTENT_OUTPUT_DIR)):
+                if os.path.exists(output_path):
+                    track_file(output_path)
                     return True, stdout, output_path
                 else:
-                    error_msg = f"Output path not found or outside persistent directory: {output_path}"
+                    error_msg = f"Output path not found: {output_path}"
                     if attempt < max_attempts:
                         print(error_msg)
                         return False, error_msg, None
@@ -689,7 +683,7 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
                     return False, "No output generated", None
                     
         except subprocess.TimeoutExpired:
-            error_msg = "Timeout: Code execution took too long (Max 90 seconds)"
+            error_msg = "Timeout: Code execution took too long"
             if attempt < max_attempts:
                 print(error_msg)
                 return False, error_msg, None
@@ -705,18 +699,13 @@ def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str
     
     return False, "Max attempts reached", None
 
-def process_request(instruction, files, urls_input):
-    """Main processing function with self-correction, supporting URLs and TalkGPT upload."""
-    
-    # 1. Cleanup before starting (to save space during heavy usage)
-    cleanup_old_files(PERSISTENT_OUTPUT_DIR)
-    
+def process_request_sync(instruction, files, urls_input):
+    """Synchronous processing function"""
     try:
         if not instruction.strip():
-            return "لطفاً دستور را وارد کنید. (فایل‌ها و لینک‌ها اختیاری هستند)", None
+            return "لطفاً دستور را وارد کنید. (فایل‌ها و لینک‌ها اختیاری هستند)", None, None
         
         file_paths = []
-        temp_dirs_to_clean = []
         
         # Handle uploaded files
         if files:
@@ -725,7 +714,7 @@ def process_request(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_')
-            temp_dirs_to_clean.append(temp_dir_for_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:
@@ -737,9 +726,7 @@ def process_request(instruction, files, urls_input):
         
         # Track errors for learning
         previous_errors = []
-        
-        final_file_path = None
-        final_output_text = ""
+        generated_codes = []
         
         # Main retry loop
         for attempt in range(1, 4):  # 3 attempts
@@ -748,6 +735,7 @@ def process_request(instruction, files, urls_input):
             print(f"{'='*50}")
             
             # Generate code
+            print("Generating code...")
             generated_code = generate_code_with_openrouter(
                 instruction, 
                 file_paths, 
@@ -756,18 +744,35 @@ def process_request(instruction, files, urls_input):
             )
             
             if len(generated_code) < 20:
-                final_output_text = f"کد ضعیف تولید شد: {generated_code}"
-                break
+                return f"کد ضعیف تولید شد: {generated_code}", None, None
+            
+            generated_codes.append(generated_code)
+            print(f"Generated code preview: {generated_code[:200]}...")
             
             # Try to execute
-            success, output, file_path = execute_code_with_retry(generated_code, max_attempts=1) # Only one execution attempt per LLM generation
+            success, output, file_path = execute_code_with_retry(generated_code, max_attempts=2)
             
             if success:
-                final_output_text = f"✅ Success on attempt {attempt}!\n\n"
-                final_output_text += f"Generated Code:\n```python\n{generated_code}\n```\n\n"
-                final_output_text += f"Output:\n{output}"
-                final_file_path = file_path
-                break # Exit retry loop on 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"
+                
+                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
             else:
                 # Analyze error
                 print(f"\n❌ Attempt {attempt} failed")
@@ -787,52 +792,61 @@ def process_request(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```"
-                    final_output_text = error_report
-                    break
+                    return error_report, None, None
         
-        # 2. Handle final output file (if one was produced)
-        uploaded_url = None
-        output_file_for_gr = None
-        
-        if final_file_path and os.path.exists(final_file_path):
-            # Attempt TalkGPT upload
-            uploaded_url = upload_to_talkgpt(final_file_path)
-            
-            if uploaded_url:
-                final_output_text += f"\n\n--- آپلود فایل ---"
-                final_output_text += f"\n✅ فایل خروجی با موفقیت در TalkGPT آپلود شد."
-                final_output_text += f"\n🔗 لینک مستقیم فایل: {uploaded_url}"
-                # Return the local file path to Gradio for download link
-                output_file_for_gr = final_file_path
-            else:
-                final_output_text += f"\n\n--- آپلود فایل ---"
-                final_output_text += f"\n⚠️ آپلود در TalkGPT ناموفق بود. فایل محلی ارائه می‌شود."
-                output_file_for_gr = final_file_path
-        
-        # 3. Cleanup downloaded files
-        for d in temp_dirs_to_clean:
-            if os.path.exists(d):
-                shutil.rmtree(d, ignore_errors=True)
-                
-        return final_output_text, output_file_for_gr
+        return "Unexpected end of retry loop", None, 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
+        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, including TalkGPT URL if available
+    if talkgpt_url:
+        # Append TalkGPT URL to result text if not already included
+        if talkgpt_url not in result_text:
+            result_text += f"\n\n📁 Direct Link: {talkgpt_url}"
+    
+    return result_text, file_path
+
+# 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)
 
 # Gradio Interface
-# 1. Set concurrency limit in gr.Blocks
-with gr.Blocks(title="AI File Processor - Self Correcting", concurrency_limit=5) as demo: 
+with gr.Blocks(title="AI File Processor - Self Correcting with TalkGPT Upload") as demo:
     gr.Markdown("""
-    # 🤖 AI File Processor - Self Correcting Edition
+    # 🤖 AI File Processor - Self Correcting Edition with TalkGPT Upload
     
     این سیستم می‌تواند:
     - کد Python تولید کند
     - خطاها را تشخیص و تحلیل کند
     - به طور خودکار مشکلات را برطرف کند
     - تا 3 بار با رویکردهای مختلف تلاش کند
-    - **فایل‌های خروجی را به صورت خودکار در TalkGPT آپلود کرده و لینک آن را ارائه دهد.**
+    - فایل‌های خروجی را به TalkGPT آپلود کند (لینک 7 روزه)
+    - چندین درخواست را همزمان پردازش کند
+    - فایل‌های قدیمی را به طور خودکار حذف کند (بعد از 24 ساعت)
     
     **مثال دستورات:**
     - "یک فایل اکسل با 1000 نام و شماره تلفن ایرانی بساز"
@@ -861,8 +875,8 @@ with gr.Blocks(title="AI File Processor - Self Correcting", concurrency_limit=5)
     btn = gr.Button("🚀 اجرا", variant="primary")
     
     with gr.Row():
-        output = gr.Textbox(label="نتیجه (شامل کد، خروجی و لینک آپلود)", lines=15)
-        file_out = gr.File(label="فایل خروجی (فایل محلی برای دانلود)", interactive=False) # Set interactive=False as the main link is in the text output
+        output = gr.Textbox(label="نتیجه", lines=15)
+        file_out = gr.File(label="فایل خروجی (اگر تولید شود، به TalkGPT آپلود می‌شود)")
     
     # Examples
     gr.Examples(
@@ -878,4 +892,4 @@ with gr.Blocks(title="AI File Processor - Self Correcting", concurrency_limit=5)
     btn.click(fn=process_request, inputs=[instruction, files, urls], outputs=[output, file_out])
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(share=True)