Update app.py

app.py

@@ -1,154 +1,231 @@
-from huggingface_hub import InferenceClient
-import gradio as gr
-import random
-import prompts
-
-client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1")
-
-def format_prompt(message, history):
-    prompt = "<s>"
-    for user_prompt, bot_response in history:
-        prompt += f"[INST] {user_prompt} [/INST]"
-        prompt += f" {bot_response}</s> "
-    prompt += f"[INST] {message} [/INST]"
-    return prompt
-
-agents = [
-    "WEB_DEV",
-    "AI_SYSTEM_PROMPT",
-    "PYTHON_CODE_DEV",
-    "CODE_REVIEW_ASSISTANT",
-    "CONTENT_WRITER_EDITOR",
-    "QUESTION_GENERATOR",
-    "HUGGINGFACE_FILE_DEV",
-]
-
-def generate(
-    prompt, history, agent_name=agents[0], sys_prompt="", temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0,
-):
-    seed = random.randint(1, 1111111111111111)
-
-    agent = prompts.WEB_DEV
-    if agent_name == "WEB_DEV":
-        agent = prompts.WEB_DEV_SYSTEM_PROMPT
-    elif agent_name == "CODE_REVIEW_ASSISTANT":
-        agent = prompts.CODE_REVIEW_ASSISTANT
-    elif agent_name == "CONTENT_WRITER_EDITOR":
-        agent = prompts.CONTENT_WRITER_EDITOR
-    elif agent_name == "SOCIAL_MEDIA_MANAGER":
-        agent = prompts.SOCIAL_MEDIA_MANAGER        
-    elif agent_name == "AI_SYSTEM_PROMPT":
-        agent = prompts.AI_SYSTEM_PROMPT
-    elif agent_name == "PYTHON_CODE_DEV":
-        agent = prompts.PYTHON_CODE_DEV        
-    elif agent_name == "QUESTION_GENERATOR":
-        agent = prompts.QUESTION_GENERATOR 
-    elif agent_name == "HUGGINGFACE_FILE_DEV":
-        agent = prompts.HUGGINGFACE_FILE_DEV          
-
-    system_prompt = agent
-    temperature = float(temperature)
-    if temperature < 1e-2:
-        temperature = 1e-2
-    top_p = float(top_p)
-
-    generate_kwargs = dict(
-        temperature=temperature,
-        max_new_tokens=max_new_tokens,
-        top_p=top_p,
-        repetition_penalty=repetition_penalty,
-        do_sample=True,
-        seed=seed,
+from typing import List, Dict, Optional, Union
+from functools import lru_cache
+from dataclasses import dataclass, field
+from enum import Enum, auto
+
+
+
+@dataclass(frozen=True)
+class WebApp:
+    code: Code
+
+    def run(self):
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.html') as f:
+            f.write(self.code.content)
+        webbrowser.open('file://' + f.name)
+        print(f"Opened WebApp in default browser. Temporary file: {f.name}")
+
+@dataclass(frozen=True)
+class GradioApp:
+    code: Code
+
+    def run(self):
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.py') as f:
+            f.write(self.code.content)
+        subprocess.run([sys.executable, f.name])
+        os.unlink(f.name)
+
+@dataclass(frozen=True)
+class StreamlitApp:
+    code: Code
+
+    def run(self):
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.py') as f:
+            f.write(self.code.content)
+        subprocess.run([sys.executable, "-m", "streamlit", "run", f.name])
+        os.unlink(f.name)
+
+@dataclass(frozen=True)
+class ReactApp:
+    code: Code
+
+    def run(self):
+        print("To run a React app, you need to set up a proper React environment.")
+        print("Here's how you might typically run a React app:")
+        print("1. Make sure you have Node.js and npm installed")
+        print("2. Create a new React app: npx create-react-app my-app")
+        print("3. Replace the contents of src/App.js with the generated code")
+        print("4. Run the app: npm start")
+        print("\nHere's the code for your App.js:")
+        print(self.code.content)
+
+class AppFactory:
+    @staticmethod
+    @lru_cache(maxsize=128)
+    def create_prompt(app_type: AppType, app_info: AppInfo) -> Prompt:
+        return Prompt(
+            content=f"""
+            Create a {app_type.name} web application with the following details:
+            Name: {app_info.name}
+            Description: {app_info.description}
+            Features: {', '.join(app_info.features)}
+            Dependencies: {', '.join(app_info.dependencies)}
+            Space: {app_info.space.content if app_info.space else 'N/A'}
+            Tutorial: {app_info.tutorial.content if app_info.tutorial else 'N/A'}
+            Please generate the code for this application.
+            """
+        )
+
+    @staticmethod
+    @lru_cache(maxsize=128)
+    def create_space(app_info: AppInfo) -> Space:
+        return Space(
+            content=f"""
+            {app_info.name}
+            {app_info.description}
+            Features: {', '.join(app_info.features)}
+            Dependencies: {', '.join(app_info.dependencies)}
+            """
+        )
+
+    @staticmethod
+    @lru_cache(maxsize=128)
+    def create_app_type_prompt(app_type: AppType, app_info: AppInfo) -> Prompt:
+        return Prompt(
+            content=f"""
+            Is the following web application a {app_type.name}?
+            {app_info.name}
+            {app_info.description}
+            Features: {', '.join(app_info.features)}
+            Dependencies: {', '.join(app_info.dependencies)}
+            Please answer with either "Yes" or "No".
+            """
+        )
+
+    @staticmethod
+    def get_app(app_type: AppType, app_info: AppInfo) -> App:
+        app_creators = {
+            AppType.WEB_APP: AppFactory._create_web_app,
+            AppType.GRADIO_APP: AppFactory._create_gradio_app,
+            AppType.STREAMLIT_APP: AppFactory._create_streamlit_app,
+            AppType.REACT_APP: AppFactory._create_react_app,
+        }
+        return app_creators[app_type](app_info)
+
+    @staticmethod
+    @lru_cache(maxsize=128)
+    def _create_web_app(app_info: AppInfo) -> WebApp:
+        code = Code(
+            content=f"""
+            <!DOCTYPE html>
+            <html lang="en">
+            <head>
+                <meta charset="UTF-8">
+                <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                <title>{app_info.name}</title>
+            </head>
+            <body>
+                <h1>{app_info.name}</h1>
+                <p>{app_info.description}</p>
+            </body>
+            </html>
+            """,
+            language="html"
+        )
+        return WebApp(code=code)
+
+    @staticmethod
+    @lru_cache(maxsize=128)
+    def _create_gradio_app(app_info: AppInfo) -> GradioApp:
+        code = Code(
+            content=f"""
+            import gradio as gr
+            def greet(name):
+                return f"Hello, {{name}}!"
+            demo = gr.Interface(greet, "text", "text")
+            if __name__ == "__main__":
+                demo.launch()
+            """,
+            language="python"
+        )
+        return GradioApp(code=code)
+
+    @staticmethod
+    @lru_cache(maxsize=128)
+    def _create_streamlit_app(app_info: AppInfo) -> StreamlitApp:
+        code = Code(
+            content=f"""
+            import streamlit as st
+            st.title('{app_info.name}')
+            st.write('{app_info.description}')
+            """,
+            language="python"
+        )
+        return StreamlitApp(code=code)
+
+    @staticmethod
+    @lru_cache(maxsize=128)
+    def _create_react_app(app_info: AppInfo) -> ReactApp:
+        code = Code(
+            content=f"""
+            import React from 'react';
+            function App() {{
+                return (
+                    <div className="App">
+                        <h1>{app_info.name}</h1>
+                        <p>{app_info.description}</p>
+                    </div>
+                );
+            }}
+            export default App;
+            """,
+            language="javascript"
+        )
+        return ReactApp(code=code)
+
+    @staticmethod
+    @lru_cache(maxsize=128)
+    def parse_tutorial(app_info: AppInfo) -> Tutorial:
+        return Tutorial(
+            content=f"""
+            ## {app_info.name} Tutorial
+            **Introduction**
+            {app_info.description}
+            **Prerequisites**
+            * Basic knowledge of web development
+            * Familiarity with {', '.join(app_info.dependencies)}
+            **Steps**
+            {chr(10).join(f"{i+1}. {feature}" for i, feature in enumerate(app_info.features))}
+            **Conclusion**
+            Congratulations! You have successfully created a {app_info.name} application.
+            """
+        )
+
+    @staticmethod
+    def generate_files(app_type: AppType, app_info: AppInfo) -> List[File]:
+        app = AppFactory.get_app(app_type, app_info)
+        file_name = {
+            AppType.WEB_APP: "index.html",
+            AppType.GRADIO_APP: "app.py",
+            AppType.STREAMLIT_APP: "app.py",
+            AppType.REACT_APP: "App.js",
+        }[app_type]
+        return [File(name=file_name, content=app.code.content, language=app.code.language)]
+
+    @staticmethod
+    def run_app(app: App):
+        app.run()
+
+if __name__ == "__main__":
+    app_info = AppInfo(
+        name="My Cool App",
+        description="A simple web application",
+        features=["Feature 1", "Feature 2", "Feature 3"],
+        dependencies=["Python", "JavaScript"],
     )
+    
+    # Create and run a WebApp
+    web_app = AppFactory.get_app(AppType.WEB_APP, app_info)
+    AppFactory.run_app(web_app)
+
+    # Create and run a GradioApp
+    gradio_app = AppFactory.get_app(AppType.GRADIO_APP, app_info)
+    AppFactory.run_app(gradio_app)
+
+    # Create and run a StreamlitApp
+    streamlit_app = AppFactory.get_app(AppType.STREAMLIT_APP, app_info)
+    AppFactory.run_app(streamlit_app)
 
-    formatted_prompt = format_prompt(f"{system_prompt}, {prompt}", history)
-    stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=False)
-    output = ""
-
-    for response in stream:
-        output += response.token.text
-        yield output
-    return output
-
-additional_inputs = [
-    gr.Dropdown(
-        label="Agents",
-        choices=[s for s in agents],
-        value=agents[0],
-        interactive=True,
-    ),
-    gr.Textbox(
-        label="System Prompt",
-        max_lines=1,
-        interactive=True,
-    ),
-    gr.Slider(
-        label="Temperature",
-        value=0.9,
-        minimum=0.0,
-        maximum=1.0,
-        step=0.05,
-        interactive=True,
-        info="Higher values produce more diverse outputs",
-    ),
-    gr.Slider(
-        label="Max new tokens",
-        value=1048 * 10,
-        minimum=0,
-        maximum=1048 * 10,
-        step=64,
-        interactive=True,
-        info="The maximum numbers of new tokens",
-    ),
-    gr.Slider(
-        label="Top-p (nucleus sampling)",
-        value=0.90,
-        minimum=0.0,
-        maximum=1,
-        step=0.05,
-        interactive=True,
-        info="Higher values sample more low-probability tokens",
-    ),
-    gr.Slider(
-        label="Repetition penalty",
-        value=1.2,
-        minimum=1.0,
-        maximum=2.0,
-        step=0.05,
-        interactive=True,
-        info="Penalize repeated tokens",
-    ),
-]
-
-examples = [
-    ["Create a simple web application using Flask", agents[0], None, None, None, None],
-    ["Generate a Python script to perform a linear regression analysis", agents[2], None, None, None, None],
-    ["Create a Dockerfile for a Node.js application", agents[1], None, None, None, None],
-    ["Write a shell script to automate the deployment of a web application to a server", agents[3], None, None, None, None],
-    ["Generate a SQL query to retrieve the top 10 most popular products by sales", agents[4], None, None, None, None],
-    ["Write a Python script to generate a random password with a given length and complexity", agents[2], None, None, None, None],
-    ["Create a simple game in Unity using C#", agents[0], None, None, None, None],
-    ["Generate a Java program to implement a binary search algorithm", agents[2], None, None, None, None],
-    ["Write a shell script to monitor the CPU usage of a server", agents[1], None, None, None, None],
-    ["Create a simple web application using React and Node.js", agents[0], None, None, None, None],
-    ["Generate a Python script to perform a sentiment analysis on a given text", agents[2], None, None, None, None],
-    ["Write a shell script to automate the backup of a MySQL database", agents[1], None, None, None, None],
-    ["Create a simple game in Unreal Engine using C++", agents[3], None, None, None, None],
-    ["Generate a Java program to implement a bubble sort algorithm", agents[2], None, None, None, None],
-    ["Write a shell script to monitor the memory usage of a server", agents[1], None, None, None, None],
-    ["Create a simple web application using Angular and Node.js", agents[0], None, None, None, None],
-    ["Generate a Python script to perform a text classification on a given dataset", agents[2], None, None, None, None],
-    ["Write a shell script to automate the installation of a software package on a server", agents[1], None, None, None, None],
-    ["Create a simple game in Godot using GDScript", agents[3], None, None, None, None],
-    ["Generate a Java program to implement a merge sort algorithm", agents[2], None, None, None, None],
-    ["Write a shell script to automate the cleanup of temporary files on a server", agents[1], None, None, None, None],
-]
-
-gr.ChatInterface(
-    fn=generate,
-    chatbot=gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel"),
-    additional_inputs=additional_inputs,
-    title="Mixtral 46.7B",
-    examples=examples,
-    concurrency_limit=20,
-).launch(show_api=False)
+    # Create and display info for a ReactApp
+    react_app = AppFactory.get_app(AppType.REACT_APP, app_info)
+    AppFactory.run_app(react_app)