Update app.py

app.py

@@ -20,7 +20,25 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 import time
 from urllib.parse import quote
 
-# Clean up any existing temp files on startup to save space
+# ================== تنظیمات لینک عمومی دانلود ==================
+# دامنه عمومی نمایش داده شده به کاربر
+PUBLIC_DOWNLOAD_BASE = "https://api.talkbot.ir/download?f=s7&g="
+
+def build_public_download_url(output_path: str) -> str:
+    """
+    تبدیل مسیر واقعی فایل روی سرور به لینک عمومی دانلود.
+    در این نسخه، g برابر است با مسیر ابسولوت URL-Encode شده.
+    اگر منطق اختصاصی (توکن، هش و ...) دارید، اینجا اعمال کنید.
+    """
+    try:
+        abs_path = os.path.abspath(output_path)
+        encoded = quote(abs_path, safe="")
+        return f"{PUBLIC_DOWNLOAD_BASE}{encoded}"
+    except Exception:
+        # اگر هر مشکلی در تولید لینک بود، برای جلوگیری از لو رفتن ساختار داخلی، چیزی خنثی برمی‌گردانیم.
+        return f"{PUBLIC_DOWNLOAD_BASE}"
+
+# ================== پاکسازی اولیه تمپ‌ها ==================
 try:
     tempdir = tempfile.gettempdir()
     for item in os.listdir(tempdir):
@@ -43,7 +61,7 @@ try:
 except:
     pass
 
-# Use OpenRouter API (OpenAI-compatible)
+# ================== OpenRouter تنظیمات ==================
 OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
 client = openai.OpenAI(
     api_key=OPENROUTER_API_KEY,
@@ -55,6 +73,7 @@ MODEL_NAME = "x-ai/grok-4-fast"
 # Global thread pool for concurrent execution
 executor = ThreadPoolExecutor(max_workers=5)  # حداکثر ۵ درخواست همزمان
 
+# ================== Session Manager ==================
 class SessionManager:
     """مدیریت سشن‌های مستقل برای هر کاربر"""
     
@@ -105,6 +124,7 @@ class SessionManager:
 # مدیر سشن گلوبال
 session_manager = SessionManager()
 
+# ================== Error Analyzer ==================
 class ErrorAnalyzer:
     """Analyze errors and suggest fixes"""
     
@@ -188,39 +208,38 @@ class ErrorAnalyzer:
             "original_error": error_message
         }
 
+# ================== Utility: Indent Code ==================
 def indent_code(code, spaces=4):
     """Indent the code by the specified number of spaces."""
     indented_lines = []
     for line in code.split('\n'):
-        if line.strip():
+        if line.strip():  # Only indent non-empty lines
             indented_lines.append(' ' * spaces + line)
         else:
             indented_lines.append(line)
     return '\n'.join(indented_lines)
 
+# ================== Package Detection ==================
 def detect_required_packages(code):
     """Detect required packages from Python code (optimized for accuracy)."""
     required_packages = set()
     
-    # Pre-installed packages from requirements.txt
+    # Pre-installed packages from requirements.txt (فرضی)
     pre_installed = {
         'gradio', 'openai', 'pillow', 'rembg', 'numpy', 'opencv-python', 'scikit-learn',
         'tensorflow', 'torch', 'lxml', 'requests', 'matplotlib', 'seaborn', 'onnxruntime',
         'proglog', 'openpyxl', 'moviepy'
     }
     
-    # Import patterns
     import_patterns = [
         r'^(?:import|from)\s+(\w+)(?:\.\w+)*',
     ]
     
-    # Patterns for pip install in code/comments
     pip_patterns = [
         r'#?\s*pip\s+install\s+([^\s#]+)',
         r'#?\s*install\s+([^\s#]+)'
     ]
     
-    # Usage patterns that require additional packages
     usage_patterns = {
         r'\.to_excel': 'openpyxl',
         r'\.read_excel': 'openpyxl',
@@ -238,7 +257,7 @@ def detect_required_packages(code):
         r'openpyxl': 'openpyxl',
     }
     
-    # Check for pip install comments
+    # pip install hints
     for pattern in pip_patterns:
         matches = re.findall(pattern, code, re.IGNORECASE | re.MULTILINE)
         for match in matches:
@@ -247,7 +266,7 @@ def detect_required_packages(code):
                 if pkg and pkg not in pre_installed:
                     required_packages.add(pkg)
     
-    # Check imports with mapping
+    # imports
     for line in code.split('\n'):
         line = line.strip()
         if line.startswith(('import ', 'from ')):
@@ -304,21 +323,20 @@ def detect_required_packages(code):
                         if module not in pre_installed:
                             required_packages.add(module)
     
-    # Check for usage patterns that need additional packages
+    # usage patterns
     for pattern, package in usage_patterns.items():
         if re.search(pattern, code, re.IGNORECASE) and package not in pre_installed:
             required_packages.add(package)
     
-    # Special case: if pandas is imported and Excel operations detected
-    if 'pandas' in code and any(pattern in code for pattern in ['.to_excel', '.read_excel', 'ExcelWriter']):
+    # pandas + excel
+    if 'pandas' in code and any(p in code for p in ['.to_excel', '.read_excel', 'ExcelWriter']):
         if 'openpyxl' not in pre_installed:
             required_packages.add('openpyxl')
     
-    # Remove pre-installed packages
     required_packages = required_packages - pre_installed
-    
     return list(required_packages)
 
+# ================== Package Installer ==================
 def install_package(package_name):
     """Install a package using pip if it's not already installed."""
     try:
@@ -381,22 +399,7 @@ def install_packages_if_needed(packages):
     
     return len(failed_packages) == 0
 
-def build_proxy_url(original_url: str) -> str:
-    """
-    تبدیل لینک اصلی به لینک پروکسی:
-    https://api.talkbot.ir/download?f=s7&g=<urlencoded(original_url)>
-    اگر از قبل به این فرمت باشد، همان را برمی‌گرداند.
-    """
-    original_url = original_url.strip()
-    if not original_url:
-        return original_url
-
-    if original_url.startswith("https://api.talkbot.ir/download?f=s7&g="):
-        return original_url
-
-    encoded = quote(original_url, safe='')
-    return f"https://api.talkbot.ir/download?f=s7&g={encoded}"
-
+# ================== Download from URL ==================
 def download_file_from_url(url: str, temp_dir: str) -> Optional[str]:
     """Download a file from URL to temp_dir and return local path."""
     try:
@@ -418,6 +421,7 @@ def download_file_from_url(url: str, temp_dir: str) -> Optional[str]:
         print(f"Failed to download {url}: {e}")
         return None
 
+# ================== Code Generation with OpenRouter ==================
 def generate_code_with_openrouter(instruction, file_paths, previous_errors=None, attempt=1):
     """Generate Python code using OpenRouter API with error awareness."""
     
@@ -441,6 +445,7 @@ 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"
     
+    # توجه: در این Template، مستقیماً لینک عمومی را با دامنه api.talkbot.ir تولید می‌کنیم
     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).
@@ -454,27 +459,26 @@ Write a complete Python script that:
 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
+7. At the end, print ONLY ONE line with:
+   OUTPUT_FILE_PATH: https://api.talkbot.ir/download?f=s7&g=<encoded_or_safe_identifier>
+   where <encoded_or_safe_identifier> is based on the output file name or path using urllib.parse.quote.
+8. Do NOT print local absolute paths of the server.
+9. If file operations fail, try alternative approaches.
 
 Important rules:
 - For pandas Excel operations, always add: # pip install openpyxl
-- Always use absolute paths with os.path.abspath()
-- Create directories before saving files
+- Always create directories before saving files
 - Handle common errors (FileNotFoundError, PermissionError, etc.)
 - If a library fails, try alternatives (e.g., csv instead of pandas)
-- No __name__ == '__main__', no functions, just direct code
+- No __name__ == '__main__', no custom functions wrapping main logic, just direct code
 - Add detailed error messages
+- Do not print debugging info; only meaningful messages and the final OUTPUT_FILE_PATH or ERROR.
+
+Example (pattern):
 
-Example with error handling:
 import os
 import tempfile
-try:
-    import pandas as pd
-    # pip install pandas openpyxl
-except ImportError:
-    print("Pandas not available, using csv module")
-    import csv
+from urllib.parse import quote
 
 file_paths = {file_paths_list}
 
@@ -482,18 +486,21 @@ try:
     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
-    
-    print(f"OUTPUT_FILE_PATH: {{os.path.abspath(output_path)}}")
+
+    # IMPORTANT: Generate safe public URL instead of local path
+    safe_id = quote(os.path.abspath(output_path), safe="")
+    public_url = f"https://api.talkbot.ir/download?f=s7&g={safe_id}"
+    print(f"OUTPUT_FILE_PATH: {public_url}")
 except Exception as e:
-    print(f"ERROR: {{e}}")
-    # Fallback solution
+    print(f"ERROR: {e}")
+    # Fallback solution (if any)
     try:
         # Alternative approach
         pass
-    except:
-        print("All approaches failed")
+    except Exception as e2:
+        print(f"ERROR: Fallback failed: {e2}")
 
 Output ONLY Python code, no markdown.
     """)
@@ -515,7 +522,12 @@ Output ONLY Python code, no markdown.
             messages=[
                 {
                     "role": "system",
-                    "content": "Output only clean executable Python code with comprehensive error handling."
+                    "content": (
+                        "Output only clean executable Python code with comprehensive error handling. "
+                        "Never include Markdown code fences. "
+                        "Always end by printing exactly one line that starts with 'OUTPUT_FILE_PATH:' "
+                        "or an 'ERROR:' message."
+                    )
                 },
                 {"role": "user", "content": prompt}
             ],
@@ -524,20 +536,25 @@ Output ONLY Python code, no markdown.
         
         generated_code = response.choices[0].message.content.strip()
         
-        # Clean code blocks if model wrapped with ```python ...```
-        generated_code = re.sub(r'^```python\s*', '', generated_code, flags=re.IGNORECASE).strip()
-        generated_code = re.sub(r'^```|```$', '', generated_code).strip()
+        # حذف احتمالی بلاک‌های ```python
+        generated_code = re.sub(r'^```python\s*', '', generated_code, flags=re.IGNORECASE | re.MULTILINE)
+        generated_code = re.sub(r'^```\s*', '', generated_code, flags=re.MULTILINE)
+        generated_code = re.sub(r'```\s*$', '', generated_code, flags=re.MULTILINE).strip()
         
-        return generated_code if generated_code else "import sys\nprint('OUTPUT_TEXT: No code generated')\nsys.exit(0)"
+        if not generated_code:
+            return "import sys\nprint('OUTPUT_TEXT: No code generated')\nsys.exit(0)"
+        
+        return generated_code
         
     except Exception as api_error:
         error_msg = f"API Error: {api_error}"
         print(error_msg)
-        # Return simple fallback
         return """import sys
-print("OUTPUT_TEXT: Code generation failed due to API error")
-sys.exit(0)"""
+print("ERROR: Code generation failed due to API error")
+sys.exit(1)
+"""
 
+# ================== Execute Code with Retry ==================
 def execute_code_with_retry(code: str, session_id: str, max_attempts: int = 3) -> Tuple[bool, str, Optional[str]]:
     """Execute code with retry logic and error recovery"""
     tf_path = None
@@ -554,11 +571,13 @@ def execute_code_with_retry(code: str, session_id: str, max_attempts: int = 3) -
             print("Detected packages:", required_packages)
             install_packages_if_needed(required_packages)
             
-            # Step 2: Wrap code
+            # Step 2: Wrap code with top-level try/except
             indented = indent_code(code)
             wrapped_code = (
                 "try:\n"
                 f"{indented}\n"
+                "except SystemExit:\n"
+                "    raise\n"
                 "except Exception as e:\n"
                 "    print(f'ERROR: {e}')\n"
                 "    import traceback; traceback.print_exc()\n"
@@ -573,16 +592,16 @@ def execute_code_with_retry(code: str, session_id: str, max_attempts: int = 3) -
             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"Syntax error on attempt {attempt}, will retry with new code")
                     return False, error_msg, None
                 else:
                     return False, error_msg, None
             
-            # Step 4: Create temp file
+            # Step 4: Create temp file in session dir
             print("Creating temp file...")
             session_temp_dir = session_manager.get_session_temp_dir(session_id)
             if not session_temp_dir:
-                session_temp_dir = tempfile.mkdtemp()
+                session_temp_dir = tempfile.mkdtemp(prefix='session_fallback_')
             
             with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, dir=session_temp_dir) as tf:
                 tf.write(wrapped_code)
@@ -608,37 +627,31 @@ def execute_code_with_retry(code: str, session_id: str, max_attempts: int = 3) -
                     pass
             
             if rc != 0:
-                error_msg = f"Execution failed (RC {rc}):\nStderr: {stderr}"
+                error_msg = f"Execution failed (RC {rc}):\nStdout: {stdout}\nStderr: {stderr}"
                 print(error_msg)
                 
                 if attempt < max_attempts:
-                    # Analyze error for potential package fixes (already partly handled above)
-                    error_analysis = ErrorAnalyzer.analyze_error(stderr, code)
-                    if error_analysis['packages']:
-                        print(f"Attempting to install missing packages: {error_analysis['packages']}")
-                        for pkg in error_analysis['packages']:
-                            install_package(pkg)
-                    return False, stderr, None
+                    return False, stdout + "\n" + stderr, None
                 else:
                     return False, error_msg, None
             
-            # Extract output
+            # Step 6: Parse OUTPUT
             output_path_match = re.search(r'OUTPUT_FILE_PATH:\s*(.+)', stdout, re.I)
             output_text_match = re.search(r'OUTPUT_TEXT:\s*(.+)', stdout, re.I | re.DOTALL)
+            error_match = re.search(r'ERROR:\s*(.+)', stdout, re.I | re.DOTALL)
             
             if output_path_match:
-                output_path = output_path_match.group(1).strip()
-                if os.path.exists(output_path):
-                    return True, stdout, output_path
-                else:
-                    error_msg = f"Output path not found: {output_path}"
-                    if attempt < max_attempts:
-                        print(error_msg)
-                        return False, error_msg, None
-                    else:
-                        return False, error_msg, None
+                public_url = output_path_match.group(1).strip()
+                # اینجا public_url مستقیماً به کاربر داده می‌شود (دامنه داخلی در آن نیست)
+                return True, public_url, None
             elif output_text_match:
                 return True, output_text_match.group(1).strip(), None
+            elif error_match:
+                # اگر فقط ERROR بود
+                if attempt < max_attempts:
+                    return False, error_match.group(1).strip(), None
+                else:
+                    return False, error_match.group(1).strip(), None
             else:
                 if stdout.strip():
                     return True, stdout, None
@@ -662,6 +675,7 @@ def execute_code_with_retry(code: str, session_id: str, max_attempts: int = 3) -
     
     return False, "Max attempts reached", None
 
+# ================== Main Async Processing ==================
 def process_request_async(instruction, files, urls_input):
     """تابع اصلی پردازش درخواست به صورت همزمان"""
     session_id = session_manager.create_session()
@@ -672,19 +686,19 @@ def process_request_async(instruction, files, urls_input):
         
         file_paths = []
         
-        # Handle uploaded files
+        # Uploaded files
         if files:
-            # Gradio File objects -> use .name (temporary file path)
-            file_paths = [f.name for f in files if f is not None]
+            for f in files:
+                if hasattr(f, 'name'):
+                    file_paths.append(f.name)
         
-        # Handle URLs via proxy domain to hide real source domain
+        # URLs -> download into session temp dir
         if urls_input and urls_input.strip():
             session_temp_dir = session_manager.get_session_temp_dir(session_id)
             urls = [url.strip() for url in urls_input.split(',') if url.strip()]
             downloaded_paths = []
             for url in urls:
-                proxy_url = build_proxy_url(url)
-                local_path = download_file_from_url(proxy_url, session_temp_dir)
+                local_path = download_file_from_url(url, session_temp_dir)
                 if local_path:
                     downloaded_paths.append(local_path)
             file_paths.extend(downloaded_paths)
@@ -693,13 +707,12 @@ def process_request_async(instruction, files, urls_input):
         previous_errors = []
         generated_codes = []
         
-        # Main retry loop
-        for attempt in range(1, 4):
-            print("\n" + "=" * 50)
+        # Main retry loop for generation+execution
+        for attempt in range(1, 4):  # 3 attempts
+            print(f"\n{'='*50}")
             print(f"MAIN ATTEMPT {attempt}/3 (Session: {session_id})")
-            print("=" * 50)
+            print(f"{'='*50}")
             
-            # Generate code
             print("Generating code...")
             generated_code = generate_code_with_openrouter(
                 instruction,
@@ -713,17 +726,19 @@ def process_request_async(instruction, files, urls_input):
                 return f"کد ضعیف تولید شد: {generated_code}", None
             
             generated_codes.append(generated_code)
-            print(f"Generated code preview: {generated_code[:200]}...")
+            print(f"Generated code preview:\n{generated_code[:400]}...\n")
             
-            # Try to execute
             success, output, file_path = execute_code_with_retry(generated_code, session_id, max_attempts=2)
             
             if success:
-                result_text = "✅ Success on attempt {}/3!\n\n".format(attempt)
-                result_text += "Generated Code:\n```python\n" + generated_code + "\n```\n\n"
-                result_text += "Output:\n" + (output if output is not None else "")
+                # در اینجا output معمولا همان لینک عمومی است
+                result_text = (
+                    f"✅ Success on attempt {attempt}!\n\n"
+                    f"Output:\n{output}"
+                )
                 session_manager.cleanup_session(session_id)
-                return result_text, file_path
+                # برای gr.File خروجی مستقیم نداریم، چون دانلود خارجی است
+                return result_text, None
             else:
                 print(f"\n❌ Attempt {attempt} failed")
                 error_analysis = ErrorAnalyzer.analyze_error(output or "", generated_code)
@@ -738,9 +753,10 @@ def process_request_async(instruction, files, urls_input):
                     for i, err in enumerate(previous_errors, 1):
                         error_report += f"\nAttempt {i}:\n"
                         error_report += f"- Error type: {err['error_type']}\n"
-                        error_report += f"- Details: {err['original_error'][:200]}...\n"
+                        error_report += f"- Details: {err['original_error'][:300]}...\n"
                     
-                    error_report += "\n\nLast generated code:\n```python\n" + generated_code + "\n```"
+                    error_report += "\n\nLast generated code (for debugging):\n"
+                    error_report += generated_code
                     session_manager.cleanup_session(session_id)
                     return error_report, None
         
@@ -753,6 +769,7 @@ def process_request_async(instruction, files, urls_input):
         session_manager.cleanup_session(session_id)
         return error_msg, None
 
+# ================== Gradio Wrapper ==================
 def process_request_wrapper(instruction, files, urls_input):
     """Wrapper function for Gradio to handle async execution"""
     future = executor.submit(process_request_async, instruction, files, urls_input)
@@ -763,7 +780,7 @@ def process_request_wrapper(instruction, files, urls_input):
     except Exception as e:
         return f"Error processing request: {str(e)}", None
 
-# Gradio Interface
+# ================== Gradio Interface ==================
 with gr.Blocks(title="AI File Processor - Self Correcting - Concurrent") as demo:
     gr.Markdown("""
     # 🤖 AI File Processor - Self Correcting Edition
@@ -783,8 +800,9 @@ with gr.Blocks(title="AI File Processor - Self Correcting - Concurrent") as demo
     - "این فایل CSV را به JSON تبدیل کن"
     
     **نکته:** می‌توانید فایل‌ها را آپلود کنید یا لینک‌های فایل را (جدا شده با کاما) وارد کنید.
-    لینک‌های دانلود به صورت خودکار به فرمت زیر تبدیل می‌شوند تا دامنه اصلی مخفی بماند:
-    https://api.talkbot.ir/download?f=s7&g=<urlencoded(original_url)>
+    
+    خروجی لینک دانلود به صورت عمومی و امن نمایش داده می‌شود، مانند:
+    https://api.talkbot.ir/download?f=s7&g=...
     """)
     
     with gr.Row():
@@ -799,15 +817,15 @@ with gr.Blocks(title="AI File Processor - Self Correcting - Concurrent") as demo
         files = gr.File(file_count="multiple", label="فایل‌های آپلود شده (اختیاری)")
         urls = gr.Textbox(
             label="لینک فایل‌ها (جدا با کاما، اختیاری)",
-            placeholder="مثال: https://example.com/file1.csv, https://example.com/file2.jpg",
-            info="پروکسی: لینک‌ها به صورت خودکار به https://api.talkbot.ir/download?f=s7&g=... تبدیل می‌شوند."
+            placeholder="https://example.com/file1.csv, https://example.com/file2.jpg",
+            info="لینک‌ها دانلود خواهند شد."
         )
     
     btn = gr.Button("🚀 اجرا", variant="primary")
     
     with gr.Row():
         output = gr.Textbox(label="نتیجه", lines=15)
-        file_out = gr.File(label="فایل خروجی (در صورت تولید)")
+        file_out = gr.File(label="فایل خروجی (در صورت نیاز داخلی)", visible=False)
     
     gr.Examples(
         examples=[
@@ -821,11 +839,10 @@ with gr.Blocks(title="AI File Processor - Self Correcting - Concurrent") as demo
     
     btn.click(fn=process_request_wrapper, inputs=[instruction, files, urls], outputs=[output, file_out])
 
+# ================== Launch ==================
 if __name__ == "__main__":
-    # Cleanup old sessions on startup
     session_manager.cleanup_old_sessions()
     
-    # Launch with concurrency settings
     try:
         demo.queue(max_size=20)
     except TypeError:
@@ -839,4 +856,4 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=7860,
         show_error=True
-    )
+    )