Update app.py

app.py

@@ -7,139 +7,154 @@ import io
 import subprocess
 import importlib.util
 import re
-from contextlib import redirect_stdout
+import textwrap
+from contextlib import redirect\_stdout
 
 # Use OpenRouter API (OpenAI-compatible)
-OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+
+OPENROUTER\_API\_KEY = os.getenv("OPENROUTER\_API\_KEY")
 client = openai.OpenAI(
-    api_key=OPENROUTER_API_KEY,
-    base_url="https://openrouter.ai/api/v1"
+api\_key=OPENROUTER\_API\_KEY,
+base\_url="[https://openrouter.ai/api/v1](https://openrouter.ai/api/v1)"
 )
 
-MODEL_NAME = "openai/gpt-oss-20b:free"
+MODEL\_NAME = "openai/gpt-oss-20b\:free"
 
-def detect_required_packages(code):
-    """Detect required packages from Python code."""
-    required_packages = set()
-    
-    # Regex patterns for detecting imports
-    import_patterns = [
-        r'import\s+(\w+)(?:\.\w+)*',
-        r'from\s+(\w+)(?:\.\w+)*\s+import',
-    ]
-    
-    # Regex patterns for detecting package installation commands (pip install)
-    pip_patterns = [
-        r'pip\s+install\s+([^\s]+)',
-        r'install\s+([^\s]+)'
-    ]
-    
-    # Check for package installations in the code itself
-    for pattern in pip_patterns:
-        matches = re.findall(pattern, code, re.IGNORECASE)
-        for match in matches:
-            if match and not match.startswith('"'):  # Simple filtering
-                required_packages.add(match.split('==')[0].split('>')[0].split('<')[0])
-    
-    # Check for standard imports that might require packages
-    lines = code.split('\n')
-    for line in lines:
-        line = line.strip()
-        if line.startswith(('import ', 'from ')):
-            # Extract module name after import/from
-            for pattern in import_patterns:
-                matches = re.findall(pattern, line)
-                for module in matches:
-                    if module and module != '__future__':
-                        # Map common module names to package names
-                        module_map = {
-                            'cv2': 'opencv-python',
-                            'sklearn': 'scikit-learn',
-                            'tf': 'tensorflow',
-                            'torch': 'torch',
-                            'numpy': 'numpy',
-                            'pandas': 'pandas',
-                            'pillow': 'Pillow',
-                            'matplotlib': 'matplotlib',
-                            'seaborn': 'seaborn',
-                            'onnxruntime': 'onnxruntime',
-                            'rembg': 'rembg',
-                            'requests': 'requests'
-                        }
-                        # Add to required packages (or map to corresponding package)
-                        if module in module_map:
-                            required_packages.add(module_map[module])
-                        else:
-                            # Use module name as package name (some cases work this way)
-                            required_packages.add(module)
-    
-    # Remove empty strings and standard library modules
-    std_libs = {
-        'os', 'sys', 'io', 'json', 're', 'time', 'math', 'random', 'collections',
-        'itertools', 'functools', 'operator', 'string', 'pathlib', 'tempfile',
-        'subprocess', 'logging', 'argparse', 'csv', 'xml', 'html', 'base64',
-        'hashlib', 'urllib', 'http', 'threading', 'multiprocessing', 'socket',
-        'asyncio', 'concurrent', 'abc', 'enum', 'dataclasses', 'typing'
-    }
-    
-    required_packages = required_packages - std_libs
-    
-    return list(required_packages)
+def detect\_required\_packages(code):
+"""Detect required packages from Python code."""
+required\_packages = set()
 
-def install_package(package_name):
-    """Install a package using pip if it's not already installed."""
-    try:
-        spec = importlib.util.find_spec(package_name)
-        if spec is None:
-            print(f"Installing package: {package_name}")
-            subprocess.check_call([
-                sys.executable, "-m", "pip", "install", "--quiet", package_name
-            ])
-            print(f"✅ {package_name} installed successfully.")
-        else:
-            print(f"✅ {package_name} already installed.")
-    except Exception as e:
-        print(f"❌ Failed to install {package_name}: {str(e)}")
-        raise RuntimeError(f"Installation failed for {package_name}: {str(e)}")
-
-def install_packages_if_needed(packages):
-    """Install all required packages."""
-    if not packages:
-        print("No packages to install.")
-        return True
-    
-    for package in packages:
-        if package:
-            try:
-                install_package(package)
-            except Exception as e:
-                print(f"⚠️ Could not install {package}: {e}")
-                # Continue with other packages even if one fails
-    
-    return True
+```
+# Regex patterns for detecting imports
+import_patterns = [
+    r'import\s+(\w+)(?:\.\w+)*',
+    r'from\s+(\w+)(?:\.\w+)*\s+import',
+]
+
+# Regex patterns for detecting package installation commands (pip install)
+pip_patterns = [
+    r'pip\s+install\s+([^\s]+)',
+    r'install\s+([^\s]+)'
+]
+
+# Check for package installations in the code itself
+for pattern in pip_patterns:
+    matches = re.findall(pattern, code, re.IGNORECASE)
+    for match in matches:
+        if match and not match.startswith('"'):  # Simple filtering
+            required_packages.add(match.split('==')[0].split('>')[0].split('<')[0])
+
+# Check for standard imports that might require packages
+lines = code.split('\n')
+for line in lines:
+    line = line.strip()
+    if line.startswith(('import ', 'from ')):
+        # Extract module name after import/from
+        for pattern in import_patterns:
+            matches = re.findall(pattern, line)
+            for module in matches:
+                if module and module != '__future__':
+                    # Map common module names to package names
+                    module_map = {
+                        'cv2': 'opencv-python',
+                        'sklearn': 'scikit-learn',
+                        'tf': 'tensorflow',
+                        'torch': 'torch',
+                        'numpy': 'numpy',
+                        'pandas': 'pandas',
+                        'pillow': 'Pillow',
+                        'matplotlib': 'matplotlib',
+                        'seaborn': 'seaborn',
+                        'onnxruntime': 'onnxruntime',
+                        'rembg': 'rembg',
+                        'requests': 'requests'
+                    }
+                    # Add to required packages (or map to corresponding package)
+                    if module in module_map:
+                        required_packages.add(module_map[module])
+                    else:
+                        # Use module name as package name (some cases work this way)
+                        required_packages.add(module)
+
+# Remove empty strings and standard library modules
+std_libs = {
+    'os', 'sys', 'io', 'json', 're', 'time', 'math', 'random', 'collections',
+    'itertools', 'functools', 'operator', 'string', 'pathlib', 'tempfile',
+    'subprocess', 'logging', 'argparse', 'csv', 'xml', 'html', 'base64',
+    'hashlib', 'urllib', 'http', 'threading', 'multiprocessing', 'socket',
+    'asyncio', 'concurrent', 'abc', 'enum', 'dataclasses', 'typing'
+}
+
+required_packages = required_packages - std_libs
+
+return list(required_packages)
+```
+
+def install\_package(package\_name):
+"""Install a package using pip if it's not already installed."""
+try:
+\# Try to detect by module name for some common packages
+module\_name = package\_name
+\# handle some known cases where package name != import name
+pkg\_to\_module = {
+'opencv-python': 'cv2',
+'Pillow': 'PIL',
+'scikit-learn': 'sklearn'
+}
+module\_name = pkg\_to\_module.get(package\_name, package\_name)
+spec = importlib.util.find\_spec(module\_name)
+if spec is None:
+print(f"Installing package: {package\_name}")
+subprocess.check\_call(\[
+sys.executable, "-m", "pip", "install", "--quiet", package\_name
+])
+print(f"✅ {package\_name} installed successfully.")
+else:
+print(f"✅ {package\_name} already installed.")
+except Exception as e:
+print(f"❌ Failed to install {package\_name}: {str(e)}")
+raise RuntimeError(f"Installation failed for {package\_name}: {str(e)}")
+
+def install\_packages\_if\_needed(packages):
+"""Install all required packages."""
+if not packages:
+print("No packages to install.")
+return True
+
+```
+for package in packages:
+    if package:
+        try:
+            install_package(package)
+        except Exception as e:
+            print(f"⚠️ Could not install {package}: {e}")
+            # Continue with other packages even if one fails
 
-def generate_code_with_openrouter(instruction, file_paths):
-    """
-    Generate Python code using OpenRouter API.
-    """
-    prompt = f"""
+return True
+```
+
+def generate\_code\_with\_openrouter(instruction, file\_paths):
+"""
+Generate Python code using OpenRouter API.
+"""
+prompt = f"""
 You are a Python expert. The user has provided the instruction: "{instruction}"
-And input files: {file_paths} (these paths are available in the current working directory).
+And input files: {file\_paths} (these paths are available in the current working directory).
 
 Write a complete, self-contained Python script that:
+
 1. Reads the input file(s) from the given paths.
 2. Performs the requested operation.
 3. Saves the output file(s) to a temporary directory (use tempfile.mkdtemp() for a temp dir).
-4. At the very end of the script, print exactly one line: OUTPUT_FILE_PATH: /full/path/to/output/file.ext
+4. At the very end of the script, print exactly one line: OUTPUT\_FILE\_PATH: /full/path/to/output/file.ext
    (Replace with the actual full path to the generated output file.)
 
 Use only safe, standard libraries or pre-installed ones. If you need additional packages outside standard libraries,
 comment them clearly at the top for proper installation.
 
 Avoid network calls and file deletion outside temporary directories. Handle errors gracefully.
-Do not define main functions or use __name__ == "__main__".
+Do not define main functions or use **name** == "**main**".
 Keep code structure clean.
-Start Code With import. and do not use try: in start.
 DO NOT USE MULTILINE STRING OR TRIPLE QUOTES INSIDE CODE.
 Do not include any markdown formatting or explanations.
 
@@ -148,276 +163,307 @@ import os
 import tempfile
 import zipfile
 
-input_path = '{file_paths[0]}'
-temp_dir = tempfile.mkdtemp()
-output_zip_path = os.path.join(temp_dir, 'output.zip')
+input\_path = '{file\_paths\[0]}'
+temp\_dir = tempfile.mkdtemp()
+output\_zip\_path = os.path.join(temp\_dir, 'output.zip')
 
 try:
-    with zipfile.ZipFile(output_zip_path, 'w', compression=zipfile.ZIP_DEFLATED) as zipf:
-        arcname = os.path.basename(input_path)
-        zipf.write(input_path, arcname=arcname)
+with zipfile.ZipFile(output\_zip\_path, 'w', compression=zipfile.ZIP\_DEFLATED) as zipf:
+arcname = os.path.basename(input\_path)
+zipf.write(input\_path, arcname=arcname)
 except Exception as e:
-    print(f"Error creating zip: {{e}}")
-    exit(1)
+print(f"Error creating zip: {{e}}")
+exit(1)
 
-print(f"OUTPUT_FILE_PATH: {{output_zip_path}}")
+print(f"OUTPUT\_FILE\_PATH: {{output\_zip\_path}}")
 
 Generate ONLY the Python code.
 """
-    
-    try:
-        response = client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=[
-                {"role": "system", "content": "You are a helpful Python code generator. Respond only with clean, executable Python code."},
-                {"role": "user", "content": prompt}
-            ],
-            max_tokens=1200,
-            temperature=0.2,
-            stop=["```"]
-        )
-        
-        generated_code = response.choices[0].message.content.strip()
-        
-        # Clean up markdown code blocks
-        if generated_code.startswith("```python"):
-            generated_code = generated_code[10:].strip()
-        if generated_code.endswith("```"):
-            generated_code = generated_code[:-3].strip()
-        
-        return generated_code
-        
-    except Exception as api_error:
-        raise api_error
 
-def safe_exec_code(code, globals_dict, locals_dict):
-    """Safely execute code and return output."""
-    try:
-        # First try to compile just to catch syntax errors
-        compiled_code = compile(code, '<string>', 'exec')
-        
-        # Run the code
-        exec(compiled_code, globals_dict, locals_dict)
-        return True, None
-    except Exception as e:
-        return False, str(e)
-
-def process_request(instruction, files):
-    if not files:
-        return "لطفاً حداقل یک فایل آپلود کنید.", None
+````
+try:
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": "You are a helpful Python code generator. Respond only with clean, executable Python code."},
+            {"role": "user", "content": prompt}
+        ],
+        max_tokens=1200,
+        temperature=0.2,
+        stop=["```"]
+    )
     
-    file_paths = [file.name for file in files]
+    generated_code = response.choices[0].message.content.strip()
     
-    try:
-        # Generate code using OpenRouter
-        generated_code = generate_code_with_openrouter(instruction, file_paths)
-        
-        if not generated_code or len(generated_code) < 50:
-            return f"کد مناسبی تولید نشد. پرامپت: {instruction}\nکد تولید شده:\n{generated_code}", None
-        
-        print("--- Generated code ---")
-        print(repr(generated_code))  # Debugging
-        print("---------------------")
-        
-        # Detect required packages
-        required_packages = detect_required_packages(generated_code)
-        print("Detected required packages:", required_packages)
-        
-        # Install required packages
-        if required_packages:
-            try:
-                install_packages_if_needed(required_packages)
-            except Exception as install_err:
-                print(f"Warning: Package installation issues: {install_err}")
-        
-        # Create a safe execution environment
-        safe_globals = {
-            '__builtins__': {
-                'print': print,
-                'open': open,
-                'range': range,
-                'len': len,
-                'str': str,
-                'int': int,
-                'float': float,
-                'list': list,
-                'dict': dict,
-                'tuple': tuple,
-                'set': set,
-                'bool': bool,
-                'type': type,
-                'isinstance': isinstance,
-                'hasattr': hasattr,
-                'getattr': getattr,
-                'setattr': setattr,
-                'delattr': delattr,
-                'abs': abs,
-                'all': all,
-                'any': any,
-                'bin': bin,
-                'chr': chr,
-                'complex': complex,
-                'divmod': divmod,
-                'enumerate': enumerate,
-                'format': format,
-                'hash': hash,
-                'hex': hex,
-                'id': id,
-                'iter': iter,
-                'max': max,
-                'min': min,
-                'next': next,
-                'oct': oct,
-                'ord': ord,
-                'pow': pow,
-                'repr': repr,
-                'round': round,
-                'slice': slice,
-                'sorted': sorted,
-                'sum': sum,
-                'zip': zip,
-                '__import__': __import__,
-                '__name__': '__main__',  # Fix for __name__ error
-                'exit': sys.exit,
-                'True': True,
-                'False': False,
-                'None': None,
-            },
-            '__name__': '__main__',  # Explicitly set __name__
-            'os': os,
-            'tempfile': tempfile,
-            'sys': sys,
-            'subprocess': subprocess,
-            'importlib': importlib,
-            're': re,
-            'json': __import__('json'),
-            'time': __import__('time'),
-            'math': __import__('math'),
-            'random': __import__('random'),
-            'collections': __import__('collections'),
-            'itertools': __import__('itertools'),
-            'functools': __import__('functools'),
-            'operator': __import__('operator'),
-            'pathlib': __import__('pathlib'),
-            'logging': __import__('logging'),
-            'argparse': __import__('argparse'),
-            'csv': __import__('csv'),
-            'base64': __import__('base64'),
-            'hashlib': __import__('hashlib'),
-            'urllib': __import__('urllib'),
-            'http': __import__('http'),
-            'socket': __import__('socket'),
-            'threading': __import__('threading'),
-            'multiprocessing': __import__('multiprocessing'),
-            'asyncio': __import__('asyncio'),
-            'concurrent': __import__('concurrent'),
-            'abc': __import__('abc'),
-            'enum': __import__('enum'),
-            'dataclasses': __import__('dataclasses'),
-            'typing': __import__('typing'),
-            'PIL': __import__('PIL', fromlist=['Image']),
-            'zipfile': __import__('zipfile'),
-            'requests': __import__('requests') if 'requests' in required_packages else None,
-        }
-        
-        # Clean up globals to remove None entries (prevents AttributeError)
-        safe_globals_clean = {k: v for k, v in safe_globals.items() if v is not None}
-        
-        # Wrap original code in try/except for clean execution
-        wrapped_code = f"""
+    # Clean up markdown code blocks
+    if generated_code.startswith("```python"):
+        generated_code = generated_code[10:].strip()
+    if generated_code.endswith("```"):
+        generated_code = generated_code[:-3].strip()
+    
+    return generated_code
+    
+except Exception as api_error:
+    raise api_error
+````
+
+def safe\_exec\_code(code, globals\_dict, locals\_dict):
+"""Safely execute code and return output."""
 try:
-{generated_code}
+\# First try to compile just to catch syntax errors
+compiled\_code = compile(code, '<string>', 'exec')
+
+```
+    # Run the code
+    exec(compiled_code, globals_dict, locals_dict)
+    return True, None
 except Exception as e:
-    print(f"ERROR: {{e}}")
-    import traceback
-    traceback.print_exc()
-    sys.exit(1)
-"""
-        
-        print("--- Wrapped code ---")
-        print(repr(wrapped_code))  # Debugging
-        print("---------------------")
-        
-        # Validate that wrapped code compiles properly
+    return False, str(e)
+```
+
+def process\_request(instruction, files):
+if not files:
+return "لطفاً حداقل یک فایل آپلود کنید.", None
+
+```
+file_paths = [file.name for file in files]
+
+try:
+    # Generate code using OpenRouter
+    generated_code = generate_code_with_openrouter(instruction, file_paths)
+    
+    if not generated_code or len(generated_code) < 50:
+        return f"کد مناسبی تولید نشد. پرامپت: {instruction}\nکد تولید شده:\n{generated_code}", None
+    
+    print("--- Generated code ---")
+    print(repr(generated_code))  # Debugging
+    print("---------------------")
+    
+    # Detect required packages
+    required_packages = detect_required_packages(generated_code)
+    print("Detected required packages:", required_packages)
+    
+    # Install required packages
+    if required_packages:
         try:
-            compile(wrapped_code, '<wrapped_string>', 'exec')
-        except SyntaxError as se:
-            return f"Syntax error in wrapped code: {se}\nWrapped code:\n{wrapped_code}", None
-        
-        # Capture output
-        f = io.StringIO()
-        output_path = None
-        
-        with redirect_stdout(f):
-            try:
-                # Execute code safely
-                exec_result, exec_error = safe_exec_code(wrapped_code, safe_globals_clean, {})
-                
-                if not exec_result:
-                    return f"Execution failed: {exec_error}\nCode:\n{wrapped_code}", None
-                
-                # Get stdout output
-                stdout_output = f.getvalue()
-                print("STDOUT OUTPUT:")
-                print(stdout_output)
+            install_packages_if_needed(required_packages)
+        except Exception as install_err:
+            print(f"Warning: Package installation issues: {install_err}")
+    
+    # Create a safe execution environment
+    # Conditionally import heavy/optional libs only if detected to avoid import errors
+    optional_imports = {}
+    if 'Pillow' in required_packages or 'PIL' in required_packages:
+        try:
+            optional_imports['PIL'] = __import__('PIL', fromlist=['Image'])
+        except Exception as e:
+            optional_imports['PIL'] = None
+            print(f"Warning: PIL import failed: {e}")
+    if 'requests' in required_packages:
+        try:
+            optional_imports['requests'] = __import__('requests')
+        except Exception as e:
+            optional_imports['requests'] = None
+            print(f"Warning: requests import failed: {e}")
+    
+    safe_globals = {
+        '__builtins__': {
+            'print': print,
+            'open': open,
+            'range': range,
+            'len': len,
+            'str': str,
+            'int': int,
+            'float': float,
+            'list': list,
+            'dict': dict,
+            'tuple': tuple,
+            'set': set,
+            'bool': bool,
+            'type': type,
+            'isinstance': isinstance,
+            'hasattr': hasattr,
+            'getattr': getattr,
+            'setattr': setattr,
+            'delattr': delattr,
+            'abs': abs,
+            'all': all,
+            'any': any,
+            'bin': bin,
+            'chr': chr,
+            'complex': complex,
+            'divmod': divmod,
+            'enumerate': enumerate,
+            'format': format,
+            'hash': hash,
+            'hex': hex,
+            'id': id,
+            'iter': iter,
+            'max': max,
+            'min': min,
+            'next': next,
+            'oct': oct,
+            'ord': ord,
+            'pow': pow,
+            'repr': repr,
+            'round': round,
+            'slice': slice,
+            'sorted': sorted,
+            'sum': sum,
+            'zip': zip,
+            '__import__': __import__,
+            'exit': sys.exit,
+            'True': True,
+            'False': False,
+            'None': None,
+        },
+        '__name__': '__main__',  # Explicitly set __name__
+        'os': os,
+        'tempfile': tempfile,
+        'sys': sys,
+        'subprocess': subprocess,
+        'importlib': importlib,
+        're': re,
+        'json': __import__('json'),
+        'time': __import__('time'),
+        'math': __import__('math'),
+        'random': __import__('random'),
+        'collections': __import__('collections'),
+        'itertools': __import__('itertools'),
+        'functools': __import__('functools'),
+        'operator': __import__('operator'),
+        'pathlib': __import__('pathlib'),
+        'logging': __import__('logging'),
+        'argparse': __import__('argparse'),
+        'csv': __import__('csv'),
+        'base64': __import__('base64'),
+        'hashlib': __import__('hashlib'),
+        'urllib': __import__('urllib'),
+        'http': __import__('http'),
+        'socket': __import__('socket'),
+        'threading': __import__('threading'),
+        'multiprocessing': __import__('multiprocessing'),
+        'asyncio': __import__('asyncio'),
+        'concurrent': __import__('concurrent'),
+        'abc': __import__('abc'),
+        'enum': __import__('enum'),
+        'dataclasses': __import__('dataclasses'),
+        'typing': __import__('typing'),
+        'zipfile': __import__('zipfile'),
+    }
+    
+    # Add optional imports only if available
+    for k, v in optional_imports.items():
+        if v is not None:
+            safe_globals[k] = v
+    
+    # Clean up globals to remove None entries (prevents AttributeError)
+    safe_globals_clean = {k: v for k, v in safe_globals.items() if v is not None}
+    
+    # Prepare wrapped code by properly indenting the generated code inside a try/except block
+    # This avoids producing an unindented 'try:' that causes SyntaxError.
+    normalized_code = generated_code.replace('\r\n', '\n').rstrip()
+    indented_code = textwrap.indent(normalized_code, '    ')
+    wrapped_code = (
+        "try:\n"
+        + indented_code
+        + "\nexcept Exception as e:\n"
+        "    print(f\"ERROR: {e}\")\n"
+        "    import traceback\n"
+        "    traceback.print_exc()\n"
+        "    sys.exit(1)\n"
+    )
+    
+    print("--- Wrapped code ---")
+    print(repr(wrapped_code))  # Debugging
+    print("---------------------")
+    
+    # Validate that wrapped code compiles properly
+    try:
+        compile(wrapped_code, '<wrapped_string>', 'exec')
+    except SyntaxError as se:
+        return f"Syntax error in wrapped code: {se}\nWrapped code:\n{wrapped_code}", None
+    
+    # Capture output
+    f = io.StringIO()
+    output_path = None
+    
+    with redirect_stdout(f):
+        try:
+            # Execute code safely
+            exec_result, exec_error = safe_exec_code(wrapped_code, safe_globals_clean, {})
+            
+            if not exec_result:
+                return f"Execution failed: {exec_error}\nCode:\n{wrapped_code}", None
+            
+            # Get stdout output
+            stdout_output = f.getvalue()
+            print("STDOUT OUTPUT:")
+            print(stdout_output)
+            
+            # Extract output file path
+            if "OUTPUT_FILE_PATH:" in stdout_output:
+                output_path = stdout_output.split("OUTPUT_FILE_PATH:")[-1].strip()
+                output_path = output_path.split('\n')[0].strip()
                 
-                # Extract output file path
-                if "OUTPUT_FILE_PATH:" in stdout_output:
-                    output_path = stdout_output.split("OUTPUT_FILE_PATH:")[-1].strip()
-                    output_path = output_path.split('\n')[0].strip()
-                    
-            except Exception as exec_error:
-                error_msg = f"Error during execution: {str(exec_error)}"
-                import traceback
-                error_msg += "\n" + traceback.format_exc()
-                return f"{error_msg}\nCode:\n{wrapped_code}", None
+        except Exception as exec_error:
+            error_msg = f"Error during execution: {str(exec_error)}"
+            import traceback
+            error_msg += "\n" + traceback.format_exc()
+            return f"{error_msg}\nCode:\n{wrapped_code}", None
+    
+    # Clean up
+    if output_path and os.path.exists(output_path):
+        result_text = f"عملیات با موفقیت انجام شد!\nکد تولید شده توسط OpenRouter:\n{wrapped_code}\n\nخروجی stdout:\n{stdout_output}"
+        return result_text, output_path
+    else:
+        return f"فایل خروجی یافت نشد. خروجی:\n{stdout_output}\nکد:\n{wrapped_code}", None
         
-        # Clean up
-        if output_path and os.path.exists(output_path):
-            result_text = f"عملیات با موفقیت انجام شد!\nکد تولید شده توسط OpenRouter:\n{wrapped_code}\n\nخروجی stdout:\n{stdout_output}"
-            return result_text, output_path
-        else:
-            return f"فایل خروجی یافت نشد. خروجی:\n{stdout_output}\nکد:\n{wrapped_code}", None
-            
-    except Exception as gen_error:
-        return f"خطا در تولید کد (OpenRouter): {str(gen_error)}\nپرامپت:\n{instruction}", None
+except Exception as gen_error:
+    return f"خطا در تولید کد (OpenRouter): {str(gen_error)}\nپرامپت:\n{instruction}", None
+```
 
 # Gradio Interface
+
 with gr.Blocks(title="AI File Processor - Final Robust Version") as demo:
-    gr.Markdown("""
+gr.Markdown("""
+
 # پردازشگر فایل با هوش مصنوعی (نسخه تمام‌خطا)
+
 ## اجرای قابل اعتماد بدون مشکل از `__name__` تا ساختار
 
 **ورژن نهایی با تمام رفع‌های خطا:**
-✅ رفع تمام تعاریف `__name__`  
-✅ رفع مشکلات ساختاری `try/except`  
-✅ اجرای امن و خطاگذار  
-✅ افزودن نیم‌ساختار `try/except` مناسب  
-✅ اعتبارسنجی دقیق پیش از اجرای کد  
+✅ رفع تمام تعاریف `__name__`
+✅ رفع مشکلات ساختاری `try/except`
+✅ اجرای امن و خطاگذار
+✅ افزودن نیم‌ساختار `try/except` مناسب
+✅ اعتبارسنجی دقیق پیش از اجرای کد
 
 **قابلیت‌ها:**
-✅ پشتیبانی از تمام عملیات پیچیده  
-✅ تشخیص خودکار پکیج‌های بیشتر  
-✅ نصب خودکار تمام ماژول‌های مورد نیاز  
-✅ گزارش‌های دقیق خطا  
+✅ پشتیبانی از تمام عملیات پیچیده
+✅ تشخیص خودکار پکیج‌های بیشتر
+✅ نصب خودکار تمام ماژول‌های مورد نیاز
+✅ گزارش‌های دقیق خطا
 
 **نوت:** این ورژن 99% از ارورها را حل کرده و با تمام کدهای تولید شده تست شده است.
 """)
 
-    with gr.Row():
-        instruction_input = gr.Textbox(label="دستور (مثال: بک گراند عکس را حذف کن)", placeholder="دستور خود را بنویسید...", lines=3)
-        files_input = gr.File(file_count="multiple", label="فایل(ها)")
-    
-    process_btn = gr.Button("پردازش با OpenRouter")
-    
-    output_text = gr.Textbox(label="نتیجه و کد", lines=15)
-    output_file = gr.File(label="فایل خروجی (لینک دانلود)")
-    
-    process_btn.click(
-        fn=process_request,
-        inputs=[instruction_input, files_input],
-        outputs=[output_text, output_file]
-    )
+```
+with gr.Row():
+    instruction_input = gr.Textbox(label="دستور (مثال: بک گراند عکس را حذف کن)", placeholder="دستور خود را بنویسید...", lines=3)
+    files_input = gr.File(file_count="multiple", label="فایل(ها)")
+
+process_btn = gr.Button("پردازش با OpenRouter")
+
+output_text = gr.Textbox(label="نتیجه و کد", lines=15)
+output_file = gr.File(label="فایل خروجی (لینک دانلود)")
+
+process_btn.click(
+    fn=process_request,
+    inputs=[instruction_input, files_input],
+    outputs=[output_text, output_file]
+)
+```
 
-if __name__ == "__main__":
-    demo.launch(share=True)
+if **name** == "**main**":
+demo.launch(share=True)