Deploy Gradio app with multiple files

app.py

@@ -0,0 +1,805 @@
+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
+    )

requirements.txt

@@ -0,0 +1 @@
+gradio>=4.0.0