Spaces:
Runtime error
Runtime error
| import gradio as gr | |
| import json | |
| import os | |
| import re | |
| import time | |
| import uuid | |
| from datetime import datetime | |
| from typing import Dict, List, Tuple, Any, Optional | |
| import subprocess | |
| import tempfile | |
| import shutil | |
| class CodeExecutionEnvironment: | |
| """Safe code execution environment with sandboxing""" | |
| def __init__(self): | |
| self.temp_dir = tempfile.mkdtemp() | |
| self.history = [] | |
| def execute_code(self, code: str, language: str = "python") -> Dict[str, Any]: | |
| """Execute code in a sandboxed environment""" | |
| execution_id = str(uuid.uuid4())[:8] | |
| timestamp = datetime.now().isoformat() | |
| try: | |
| if language.lower() == "python": | |
| result = self._execute_python(code) | |
| elif language.lower() == "javascript": | |
| result = self._execute_javascript(code) | |
| elif language.lower() == "bash": | |
| result = self._execute_bash(code) | |
| else: | |
| result = {"output": f"Language {language} not supported", "error": True} | |
| execution_record = { | |
| "id": execution_id, | |
| "timestamp": timestamp, | |
| "code": code, | |
| "language": language, | |
| "result": result | |
| } | |
| self.history.append(execution_record) | |
| return result | |
| except Exception as e: | |
| return { | |
| "output": f"Execution error: {str(e)}", | |
| "error": True, | |
| "execution_id": execution_id | |
| } | |
| def _execute_python(self, code: str) -> Dict[str, Any]: | |
| """Execute Python code safely""" | |
| try: | |
| # Create a temporary file | |
| temp_file = os.path.join(self.temp_dir, f"temp_{uuid.uuid4()}.py") | |
| with open(temp_file, 'w') as f: | |
| f.write(code) | |
| # Execute with timeout | |
| result = subprocess.run( | |
| ['python', temp_file], | |
| capture_output=True, | |
| text=True, | |
| timeout=30, | |
| cwd=self.temp_dir | |
| ) | |
| return { | |
| "output": result.stdout, | |
| "error": result.returncode != 0, | |
| "stderr": result.stderr if result.stderr else None | |
| } | |
| except subprocess.TimeoutExpired: | |
| return {"output": "Code execution timed out (30s limit)", "error": True} | |
| except Exception as e: | |
| return {"output": f"Python execution error: {str(e)}", "error": True} | |
| def _execute_javascript(self, code: str) -> Dict[str, Any]: | |
| """Execute JavaScript code using Node.js""" | |
| try: | |
| temp_file = os.path.join(self.temp_dir, f"temp_{uuid.uuid4()}.js") | |
| with open(temp_file, 'w') as f: | |
| f.write(code) | |
| result = subprocess.run( | |
| ['node', temp_file], | |
| capture_output=True, | |
| text=True, | |
| timeout=30, | |
| cwd=self.temp_dir | |
| ) | |
| return { | |
| "output": result.stdout, | |
| "error": result.returncode != 0, | |
| "stderr": result.stderr if result.stderr else None | |
| } | |
| except subprocess.TimeoutExpired: | |
| return {"output": "Code execution timed out (30s limit)", "error": True} | |
| except FileNotFoundError: | |
| return {"output": "Node.js not found. Please install Node.js to run JavaScript.", "error": True} | |
| except Exception as e: | |
| return {"output": f"JavaScript execution error: {str(e)}", "error": True} | |
| def _execute_bash(self, code: str) -> Dict[str, Any]: | |
| """Execute bash commands""" | |
| try: | |
| result = subprocess.run( | |
| code, | |
| shell=True, | |
| capture_output=True, | |
| text=True, | |
| timeout=30, | |
| cwd=self.temp_dir | |
| ) | |
| return { | |
| "output": result.stdout, | |
| "error": result.returncode != 0, | |
| "stderr": result.stderr if result.stderr else None | |
| } | |
| except subprocess.TimeoutExpired: | |
| return {"output": "Command execution timed out (30s limit)", "error": True} | |
| except Exception as e: | |
| return {"output": f"Bash execution error: {str(e)}", "error": True} | |
| def cleanup(self): | |
| """Clean up temporary files""" | |
| try: | |
| shutil.rmtree(self.temp_dir) | |
| except: | |
| pass | |
| class AICodeAssistant: | |
| """AI-powered code generation and assistance""" | |
| def __init__(self): | |
| self.templates = { | |
| "react": """import React from 'react'; | |
| function Component() {{ | |
| return ( | |
| <div> | |
| <h1>Hello World</h1> | |
| </div> | |
| ); | |
| }} | |
| export default Component;""", | |
| "python": """def main(): | |
| print("Hello, World!") | |
| if __name__ == "__main__": | |
| main()""", | |
| "fastapi": """from fastapi import FastAPI | |
| app = FastAPI() | |
| @app.get("/") | |
| def read_root(): | |
| return {{"message": "Hello World"}}""", | |
| "gradio": """import gradio as gr | |
| def greet(name): | |
| return f"Hello {name}!" | |
| demo = gr.Interface(fn=greet, inputs="text", outputs="text") | |
| demo.launch()""", | |
| "express": """const express = require('express'); | |
| const app = express(); | |
| const port = 3000; | |
| app.get('/', (req, res) => { | |
| res.json({ message: 'Hello World!' }); | |
| }); | |
| app.listen(port, () => { | |
| console.log(`Server running at http://localhost:${port}`); | |
| });""", | |
| } | |
| def generate_code(self, prompt: str, language: str, context: str = "") -> str: | |
| """Generate code based on prompt and language""" | |
| # Enhanced code generation with context awareness | |
| language = language.lower() | |
| # Check for template usage | |
| if any(template in prompt.lower() for template in ["react", "component", "jsx"]): | |
| return self.templates["react"] | |
| elif "fastapi" in prompt.lower(): | |
| return self.templates["fastapi"] | |
| elif "gradio" in prompt.lower(): | |
| return self.templates["gradio"] | |
| elif "express" in prompt.lower(): | |
| return self.templates["express"] | |
| elif "python" in prompt.lower() or language == "python": | |
| return self.templates["python"] | |
| # Generate code based on common patterns | |
| if "function" in prompt.lower() or "def" in prompt.lower(): | |
| if language == "python": | |
| return f"""def {prompt.split()[-1] if prompt.split() else 'function_name'}(): | |
| # TODO: Implement function | |
| pass | |
| # Example usage | |
| if __name__ == "__main__": | |
| result = {prompt.split()[-1] if prompt.split() else 'function_name'}() | |
| print(result)""" | |
| elif language in ["javascript", "js"]: | |
| return f"""function {prompt.split()[-1] if prompt.split() else 'functionName'}() {{ | |
| // TODO: Implement function | |
| console.log("Function called"); | |
| }} | |
| // Example usage | |
| {prompt.split()[-1] if prompt.split() else 'functionName'}();""" | |
| # Default response | |
| return f"""// Generated code for: {prompt} | |
| // Language: {language} | |
| // TODO: Implement your solution here | |
| console.log("Code generated for: {prompt}");""" | |
| def explain_code(self, code: str) -> str: | |
| """Provide explanation for code""" | |
| lines = code.split('\n') | |
| explanation = "Code Analysis:\n\n" | |
| # Simple pattern-based explanation | |
| for i, line in enumerate(lines[:10], 1): # Limit to first 10 lines | |
| line = line.strip() | |
| if not line or line.startswith('//') or line.startswith('#'): | |
| continue | |
| if 'def ' in line: | |
| explanation += f"Line {i}: Function definition - {line}\n" | |
| elif 'function ' in line: | |
| explanation += f"Line {i}: Function declaration - {line}\n" | |
| elif 'import ' in line: | |
| explanation += f"Line {i}: Import statement - {line}\n" | |
| elif 'class ' in line: | |
| explanation += f"Line {i}: Class definition - {line}\n" | |
| elif '=' in line: | |
| explanation += f"Line {i}: Variable assignment - {line}\n" | |
| else: | |
| explanation += f"Line {i}: Code statement - {line}\n" | |
| return explanation + "\nThis is a basic analysis. For detailed explanations, consider adding more context." | |
| def debug_code(self, code: str, error_message: str) -> str: | |
| """Provide debugging suggestions""" | |
| suggestions = [ | |
| "Check for syntax errors and typos", | |
| "Verify all variables are properly declared", | |
| "Ensure proper indentation", | |
| "Check for missing imports or dependencies", | |
| "Review logic flow and control structures" | |
| ] | |
| debug_help = f"Debugging Suggestions for Error: {error_message}\n\n" | |
| debug_help += "\n".join(f"• {suggestion}" for suggestion in suggestions) | |
| # Add specific suggestions based on error patterns | |
| if "syntax" in error_message.lower(): | |
| debug_help += "\n\nSyntax Error Specific:\n• Check for missing colons, brackets, or quotes\n• Verify proper indentation" | |
| elif "undefined" in error_message.lower(): | |
| debug_help += "\n\nUndefined Error Specific:\n• Check variable scope\n• Ensure variables are declared before use" | |
| elif "import" in error_message.lower(): | |
| debug_help += "\n\nImport Error Specific:\n• Verify module names are correct\n• Check if required packages are installed" | |
| return debug_help | |
| class CodeIDE: | |
| """Main IDE application""" | |
| def __init__(self): | |
| self.executor = CodeExecutionEnvironment() | |
| self.assistant = AICodeAssistant() | |
| self.current_file = None | |
| self.files = {} | |
| self.chat_history = [] | |
| def create_new_file(self, filename: str, content: str = "") -> str: | |
| """Create a new file""" | |
| if not filename: | |
| return "Error: Filename cannot be empty" | |
| self.files[filename] = content | |
| self.current_file = filename | |
| return f"Created file: {filename}" | |
| def save_file(self, filename: str, content: str) -> str: | |
| """Save file content""" | |
| self.files[filename] = content | |
| return f"Saved: {filename}" | |
| def load_file(self, filename: str) -> Tuple[str, str]: | |
| """Load file content""" | |
| if filename in self.files: | |
| self.current_file = filename | |
| return self.files[filename], f"Loaded: {filename}" | |
| else: | |
| return "", f"File not found: {filename}" | |
| def delete_file(self, filename: str) -> str: | |
| """Delete a file""" | |
| if filename in self.files: | |
| del self.files[filename] | |
| if self.current_file == filename: | |
| self.current_file = None | |
| return f"Deleted: {filename}" | |
| else: | |
| return f"File not found: {filename}" | |
| def get_file_list(self) -> List[str]: | |
| """Get list of all files""" | |
| return list(self.files.keys()) | |
| def generate_code_response(self, message: str, language: str, current_code: str = "") -> str: | |
| """Generate AI response for code generation""" | |
| response = self.assistant.generate_code(message, language, current_code) | |
| # Add to chat history | |
| self.chat_history.append({"role": "user", "content": message}) | |
| self.chat_history.append({"role": "assistant", "content": response}) | |
| return response | |
| def explain_code_response(self, code: str) -> str: | |
| """Explain code with AI""" | |
| explanation = self.assistant.explain_code(code) | |
| self.chat_history.append({"role": "user", "content": "Explain this code"}) | |
| self.chat_history.append({"role": "assistant", "content": explanation}) | |
| return explanation | |
| def debug_code_response(self, code: str, error: str) -> str: | |
| """Debug code with AI""" | |
| debug_suggestion = self.assistant.debug_code(code, error) | |
| self.chat_history.append({"role": "user", "content": f"Debug this error: {error}"}) | |
| self.chat_history.append({"role": "assistant", "content": debug_suggestion}) | |
| return debug_suggestion | |
| def execute_current_code(self, code: str, language: str) -> Dict[str, Any]: | |
| """Execute the current code""" | |
| result = self.executor.execute_code(code, language) | |
| return result | |
| def get_chat_history(self) -> List[Dict[str, str]]: | |
| """Get chat history""" | |
| return self.chat_history | |
| def clear_chat_history(self) -> str: | |
| """Clear chat history""" | |
| self.chat_history = [] | |
| return "Chat history cleared" | |
| # Initialize IDE | |
| ide = CodeIDE() | |
| def create_interface(): | |
| """Create the Gradio interface""" | |
| with gr.Blocks( | |
| title="AnyCoder - AI Code Generation IDE", | |
| theme=gr.themes.Soft(), | |
| css=""" | |
| .header { | |
| background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); | |
| padding: 20px; | |
| border-radius: 10px; | |
| margin-bottom: 20px; | |
| text-align: center; | |
| } | |
| .header h1 { | |
| color: white; | |
| margin: 0; | |
| font-size: 2.5em; | |
| } | |
| .header p { | |
| color: rgba(255,255,255,0.9); | |
| margin: 10px 0 0 0; | |
| font-size: 1.1em; | |
| } | |
| .header a { | |
| color: white; | |
| text-decoration: underline; | |
| } | |
| .code-editor { | |
| font-family: 'Courier New', monospace; | |
| font-size: 14px; | |
| } | |
| .chat-container { | |
| height: 400px; | |
| overflow-y: auto; | |
| } | |
| """ | |
| ) as demo: | |
| with gr.Row(): | |
| gr.HTML(""" | |
| <div class="header"> | |
| <h1>🚀 AnyCoder</h1> | |
| <p>Uncensored AI Code Generation IDE with Conversational Assistant</p> | |
| <p>Built with <a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank">anycoder</a></p> | |
| </div> | |
| """) | |
| with gr.Tabs() as tabs: | |
| # Code Editor Tab | |
| with gr.TabItem("💻 Code Editor", id="editor"): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("### 📁 File Manager") | |
| file_list = gr.Dropdown( | |
| choices=ide.get_file_list(), | |
| label="Select File", | |
| interactive=True | |
| ) | |
| new_file_name = gr.Textbox(label="New File Name", placeholder="example.py") | |
| with gr.Row(): | |
| create_btn = gr.Button("📄 New", variant="primary") | |
| save_btn = gr.Button("💾 Save", variant="secondary") | |
| delete_btn = gr.Button("🗑️ Delete", variant="stop") | |
| gr.Markdown("### ⚙️ Settings") | |
| language_select = gr.Dropdown( | |
| choices=["python", "javascript", "bash", "html", "css"], | |
| value="python", | |
| label="Language" | |
| ) | |
| with gr.Row(): | |
| run_btn = gr.Button("▶️ Run Code", variant="primary") | |
| clear_btn = gr.Button("🧹 Clear") | |
| with gr.Column(scale=2): | |
| gr.Markdown("### 📝 Code Editor") | |
| code_editor = gr.Code( | |
| label="Code", | |
| language="python", | |
| lines=20, | |
| elem_classes=["code-editor"] | |
| ) | |
| gr.Markdown("### 📊 Output") | |
| output_display = gr.Code( | |
| label="Execution Output", | |
| language="text", | |
| lines=10, | |
| interactive=False | |
| ) | |
| # AI Assistant Tab | |
| with gr.TabItem("🤖 AI Assistant", id="assistant"): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("### 💬 Chat with AI") | |
| chatbot = gr.Chatbot( | |
| type="messages", | |
| elem_classes=["chat-container"], | |
| height=400 | |
| ) | |
| with gr.Row(): | |
| msg_input = gr.Textbox( | |
| label="Ask for code help...", | |
| placeholder="Generate a React component for a todo list", | |
| lines=2 | |
| ) | |
| send_btn = gr.Button("📤 Send", variant="primary") | |
| with gr.Row(): | |
| clear_chat_btn = gr.Button("🧹 Clear Chat") | |
| explain_btn = gr.Button("📖 Explain Code") | |
| debug_btn = gr.Button("🐛 Debug Code") | |
| with gr.Column(scale=1): | |
| gr.Markdown("### 🎯 Quick Actions") | |
| with gr.Accordion("Code Templates", open=True): | |
| template_select = gr.Dropdown( | |
| choices=["React Component", "FastAPI", "Gradio", "Express", "Python Function"], | |
| label="Select Template", | |
| value="React Component" | |
| ) | |
| use_template_btn = gr.Button("📋 Use Template", variant="secondary") | |
| gr.Markdown("### 🛠️ AI Tools") | |
| ai_language = gr.Dropdown( | |
| choices=["python", "javascript", "react", "html", "css"], | |
| value="python", | |
| label="Target Language" | |
| ) | |
| gr.Markdown("### 📚 Recent History") | |
| history_display = gr.JSON( | |
| label="Chat History", | |
| value=ide.get_chat_history() | |
| ) | |
| # Project Files Tab | |
| with gr.TabItem("📂 Project Files", id="files"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| gr.Markdown("### 📋 All Files") | |
| files_display = gr.DataFrame( | |
| headers=["Filename", "Size", "Type"], | |
| datatype=["str", "str", "str"], | |
| interactive=False | |
| ) | |
| refresh_files_btn = gr.Button("🔄 Refresh Files", variant="primary") | |
| gr.Markdown("### 📤 Export Project") | |
| export_format = gr.Dropdown( | |
| choices=["ZIP", "JSON"], | |
| value="ZIP", | |
| label="Export Format" | |
| ) | |
| export_btn = gr.Button("📦 Export Project") | |
| gr.Markdown("### 📥 Import Project") | |
| import_file = gr.File( | |
| label="Import Project File", | |
| file_types=[".zip", ".json"] | |
| ) | |
| import_btn = gr.Button("📥 Import") | |
| with gr.Column(): | |
| gr.Markdown("### 📊 Project Statistics") | |
| stats_display = gr.JSON( | |
| label="Statistics", | |
| value={} | |
| ) | |
| gr.Markdown("### 🕐 Execution History") | |
| exec_history = gr.DataFrame( | |
| headers=["Time", "Language", "Status"], | |
| datatype=["str", "str", "str"], | |
| interactive=False | |
| ) | |
| # Settings Tab | |
| with gr.TabItem("⚙️ Settings", id="settings"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| gr.Markdown("### 🎨 Theme Settings") | |
| theme_select = gr.Dropdown( | |
| choices=["Soft", "Base", "Default", "Monochrome"], | |
| value="Soft", | |
| label="Theme" | |
| ) | |
| gr.Markdown("### 🔧 Editor Settings") | |
| font_size = gr.Slider( | |
| minimum=10, | |
| maximum=24, | |
| value=14, | |
| step=1, | |
| label="Font Size" | |
| ) | |
| tab_size = gr.Slider( | |
| minimum=2, | |
| maximum=8, | |
| value=4, | |
| step=1, | |
| label="Tab Size" | |
| ) | |
| gr.Markdown("### 🤖 AI Settings") | |
| ai_temperature = gr.Slider( | |
| minimum=0.1, | |
| maximum=1.0, | |
| value=0.7, | |
| step=0.1, | |
| label="AI Creativity" | |
| ) | |
| max_tokens = gr.Slider( | |
| minimum=100, | |
| maximum=2000, | |
| value=1000, | |
| step=100, | |
| label="Max Response Length" | |
| ) | |
| with gr.Column(): | |
| gr.Markdown("### 🚀 Advanced Settings") | |
| auto_save = gr.Checkbox( | |
| label="Auto-save files", | |
| value=True | |
| ) | |
| line_numbers = gr.Checkbox( | |
| label="Show line numbers", | |
| value=True | |
| ) | |
| word_wrap = gr.Checkbox( | |
| label="Word wrap", | |
| value=False | |
| ) | |
| gr.Markdown("### 🔄 Reset Options") | |
| with gr.Row(): | |
| reset_settings_btn = gr.Button("🔄 Reset Settings", variant="secondary") | |
| clear_all_btn = gr.Button("🗑️ Clear All Data", variant="stop") | |
| # Event Handlers | |
| def create_file(filename): | |
| if filename: | |
| result = ide.create_new_file(filename) | |
| return result, gr.Dropdown(choices=ide.get_file_list(), value=filename) | |
| return "Please enter a filename", gr.Dropdown() | |
| def save_file(filename, content): | |
| if filename: | |
| return ide.save_file(filename, content) | |
| return "No file selected" | |
| def load_file(filename): | |
| if filename: | |
| content, message = ide.load_file(filename) | |
| return content, message | |
| return "", "No file selected" | |
| def delete_file(filename): | |
| if filename: | |
| result = ide.delete_file(filename) | |
| return result, gr.Dropdown(choices=ide.get_file_list()) | |
| return "No file selected", gr.Dropdown() | |
| def run_code(code, language): | |
| if code: | |
| result = ide.execute_current_code(code, language) | |
| output = result.get("output", "") | |
| if result.get("error"): | |
| output = f"ERROR:\n{output}\n\nSTDERR:\n{result.get('stderr', '')}" | |
| return output | |
| return "No code to run" | |
| def chat_response(message, history, language, code): | |
| if not message: | |
| return "", history | |
| # Generate AI response | |
| response = ide.generate_code_response(message, language, code) | |
| history.append({"role": "user", "content": message}) | |
| history.append({"role": "assistant", "content": response}) | |
| return "", history | |
| def explain_current_code(code, history): | |
| if code: | |
| explanation = ide.explain_code_response(code) | |
| history.append({"role": "user", "content": "Explain the current code"}) | |
| history.append({"role": "assistant", "content": explanation}) | |
| return history | |
| def debug_current_code(code, history): | |
| if code: | |
| # Simulate finding an error | |
| debug_response = ide.debug_code_response(code, "Example error message") | |
| history.append({"role": "user", "content": "Debug the current code"}) | |
| history.append({"role": "assistant", "content": debug_response}) | |
| return history | |
| def use_template(template, language): | |
| template_map = { | |
| "React Component": "react", | |
| "FastAPI": "fastapi", | |
| "Gradio": "gradio", | |
| "Express": "express", | |
| "Python Function": "python" | |
| } | |
| template_key = template_map.get(template, "python") | |
| return ide.assistant.templates.get(template_key, "# Template not found") | |
| def clear_chat(): | |
| ide.clear_chat_history() | |
| return [] | |
| def refresh_files(): | |
| files = ide.get_file_list() | |
| file_data = [] | |
| for file in files: | |
| content = ide.files.get(file, "") | |
| file_data.append([file, f"{len(content)} chars", file.split('.')[-1] if '.' in file else "text"]) | |
| return file_data | |
| def update_stats(): | |
| files = ide.get_file_list() | |
| total_chars = sum(len(ide.files.get(f, "")) for f in files) | |
| return { | |
| "total_files": len(files), | |
| "total_characters": total_chars, | |
| "languages": list(set(f.split('.')[-1] if '.' in f else "text" for f in files)), | |
| "chat_messages": len(ide.chat_history) | |
| } | |
| def get_exec_history(): | |
| history = [] | |
| for record in ide.executor.history[-10:]: # Last 10 executions | |
| status = "✅ Success" if not record["result"].get("error") else "❌ Error" | |
| history.append([record["timestamp"], record["language"], status]) | |
| return history | |
| # Wire up events | |
| create_btn.click( | |
| create_file, | |
| inputs=[new_file_name], | |
| outputs=[gr.Textbox(label="Status"), file_list] | |
| ) | |
| save_btn.click( | |
| save_file, | |
| inputs=[file_list, code_editor], | |
| outputs=[gr.Textbox(label="Status")] | |
| ) | |
| file_list.change( | |
| load_file, | |
| inputs=[file_list], | |
| outputs=[code_editor, gr.Textbox(label="Status")] | |
| ) | |
| delete_btn.click( | |
| delete_file, | |
| inputs=[file_list], | |
| outputs=[gr.Textbox(label="Status"), file_list] | |
| ) | |
| run_btn.click( | |
| run_code, | |
| inputs=[code_editor, language_select], | |
| outputs=[output_display] | |
| ) | |
| clear_btn.click( | |
| lambda: ("", ""), | |
| outputs=[code_editor, output_display] | |
| ) | |
| send_btn.click( | |
| chat_response, | |
| inputs=[msg_input, chatbot, ai_language, code_editor], | |
| outputs=[msg_input, chatbot] | |
| ) | |
| msg_input.submit( | |
| chat_response, | |
| inputs=[msg_input, chatbot, ai_language, code_editor], | |
| outputs=[msg_input, chatbot] | |
| ) | |
| clear_chat_btn.click( | |
| clear_chat, | |
| outputs=[chatbot] | |
| ) | |
| explain_btn.click( | |
| explain_current_code, | |
| inputs=[code_editor, chatbot], | |
| outputs=[chatbot] | |
| ) | |
| debug_btn.click( | |
| debug_current_code, | |
| inputs=[code_editor, chatbot], | |
| outputs=[chatbot] | |
| ) | |
| use_template_btn.click( | |
| use_template, | |
| inputs=[template_select, ai_language], | |
| outputs=[code_editor] | |
| ) | |
| refresh_files_btn.click( | |
| refresh_files, | |
| outputs=[files_display] | |
| ) | |
| # Initialize displays | |
| demo.load( | |
| fn=lambda: (refresh_files(), update_stats(), get_exec_history()), | |
| outputs=[files_display, stats_display, exec_history] | |
| ) | |
| return demo | |
| # Create and launch the application | |
| if __name__ == "__main__": | |
| demo = create_interface() | |
| demo.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| share=True, | |
| show_error=True, | |
| show_api=True | |
| ) |