Update app.py

app.py

@@ -1,36 +1,4 @@
-from huggingface_hub import InferenceClient
-import gradio as gr
-import random
-from logx import prompts
-import os
-import sys
-import json
-from typing import List, Dict
-
-# Import necessary modules from other files
-import { createLlamaPrompt } from "./createLlamaPrompt.mts";
-import { createSpace } from "./createSpace.mts";
-import { isPythonOrGradioAppPrompt } from "./isPythonOrGradioAppPrompt.mts";
-import { isReactAppPrompt } from "./isReactAppPrompt.mts";
-import { isStreamlitAppPrompt } from "./isStreamlitAppPrompt.mts";
-import { getWebApp } from "./getWebApp.mts";
-import { getGradioApp } from "./getGradioApp.mts";
-import { getReactApp } from "./getReactApp.mts";
-import { getStreamlitApp } from "./getStreamlitApp.mts";
-import { parseTutorial } from "./parseTutorial.mts";
-import { generateFiles } from "./generateFiles.mts";
-import { createLlamaPrompt } from "./createLlamaPrompt.mts";
-import { createSpace } from "./createSpace.mts";
-import { isPythonOrGradioAppPrompt } from "./isPythonOrGradioAppPrompt.mts";
-import { isReactAppPrompt } from "./isReactAppPrompt.mts";
-import { isStreamlitAppPrompt } from "./isStreamlitAppPrompt.mts";
-import { getWebApp } from "./getWebApp.mts";
-import { getGradioApp } from "./getGradioApp.mts";
-import { getReactApp } from "./getReactApp.mts";
-import { getStreamlitApp } from "./getStreamlitApp.mts";
-import { parseTutorial } from "./parseTutorial.mts";
-import { generateFiles } from "./generateFiles.mts";
-from agent import Agent
+from typing import List, Dict, Optional
 from types import (
     Code,
     Prompt,
@@ -45,197 +13,267 @@ from types import (
     ReactApp,
     Code,
 )
-
-client = InferenceClient(
-    "mistralai/Mixtral-8x7B-Instruct-v0.1"
+from agent import Agent
+from prompts import (
+    createLlamaPrompt,
+    createSpace,
+    isPythonOrGradioAppPrompt,
+    isReactAppPrompt,
+    isStreamlitAppPrompt,
+    getWebApp,
+    getGradioApp,
+    getReactApp,
+    getStreamlitApp,
+    parseTutorial,
+    generateFiles,
 )
+from huggingface_hub import InferenceClient
 
-def run():
-    text_output = "Some text output"
-    chatbot_output = [{"text": "Chatbot response"}]
-    
-    return text_output, chatbot_output
+class Agent:
+    def __init__(self, prompts: Dict[str, any]):
+        self.prompts = prompts
+        self.client = InferenceClient(
+            "mistralai/Mixtral-8x7B-Instruct-v0.1"
+        )
 
-# Ensure the function is properly linked to the event
-interface = gr.Interface(fn=run, inputs=[...], outputs=[gr.Textbox(), gr.Chatbot()])
+    def process(self, user_input: str) -> str:
+        """
+        Processes the user's input and generates code.
+        """
 
-# Define the main function
-def main():
-    """
-    Main function that orchestrates the code generation process.
-    """
+        # Parse the user's input
+        app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial = self.parse_input(user_input)
 
-    # Load prompts from prompts.py
-    prompts = load_prompts()
+        # Generate a prompt for the Llama model
+        prompt = self.prompts["createLlamaPrompt"](
+            app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial
+        )
 
-    # Initialize an Agent instance
-    agent = Agent(prompts)
+        # Generate code using the Llama model
+        code = self.generate_code(prompt)
 
-    # Get the user's input
-    user_input = input("Enter your prompt: ")
+        # Generate files for the application
+        files = self.prompts["generateFiles"](
+            app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial
+        )
 
-    # Process the user's input
-    result = agent.process(user_input)
+        # Return the generated code and files
+        return f"Code: {code}\nFiles: {files}"
 
-    # Print the result
-    print(result)
+    def parse_input(self, user_input: str) -> tuple:
+        """
+        Parses the user's input and extracts the relevant information.
+        """
 
-# Function to load prompts from prompts.py
-def load_prompts():
-    """
-    Loads prompts from prompts.py.
-    """
+        # Extract the app type
+        app_type = self.extract_app_type(user_input)
 
-    prompts = {
-        "createLlamaPrompt": createLlamaPrompt,
-        "createSpace": createSpace,
-        "isPythonOrGradioAppPrompt": isPythonOrGradioAppPrompt,
-        "isReactAppPrompt": isReactAppPrompt,
-        "isStreamlitAppPrompt": isStreamlitAppPrompt,
-        "getWebApp": getWebApp,
-        "getGradioApp": getGradioApp,
-        "getReactApp": getReactApp,
-        "getStreamlitApp": getStreamlitApp,
-        "parseTutorial": parseTutorial,
-        "generateFiles": generateFiles,
-    }
+        # Extract the app name
+        app_name = self.extract_app_name(user_input)
 
-    return prompts
+        # Extract the app description
+        app_description = self.extract_app_description(user_input)
 
-# Indentation corrected here
-def create_prompt(app_type: str, app_name: str, app_description: str, app_features: list[str], app_dependencies: list[str], app_space: str, app_tutorial: str) -> str:
-    prompt = f"""
-I need you to help me create a {app_type} web application. 
+        # Extract the app features
+        app_features = self.extract_app_features(user_input)
 
-The application name is: {app_name}
+        # Extract the app dependencies
+        app_dependencies = self.extract_app_dependencies(user_input)
 
-The application description is: {app_description}
+        # Extract the app space
+        app_space = self.extract_app_space(user_input)
 
-The application features are: {app_features}
+        # Extract the app tutorial
+        app_tutorial = self.extract_app_tutorial(user_input)
 
-The application dependencies are: {app_dependencies}
+        return app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial
 
-The application space is: {app_space}
+    def extract_app_type(self, user_input: str) -> AppType:
+        """
+        Extracts the app type from the user's input.
+        """
 
-The application tutorial is: {app_tutorial}
+        # Check if the user specified a specific app type
+        if "web app" in user_input:
+            return AppType.WEB_APP
+        elif "gradio app" in user_input:
+            return AppType.GRADIO_APP
+        elif "streamlit app" in user_input:
+            return AppType.STREAMLIT_APP
+        elif "react app" in user_input:
+            return AppType.REACT_APP
 
-Please generate the code for the application.
-    """
-    return prompt
-
-    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
-
-    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)
-
-        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,
+        # Otherwise, assume the user wants a web app
+        return AppType.WEB_APP
+
+    def extract_app_name(self, user_input: str) -> str:
+        """
+        Extracts the app name from the user's input.
+        """
+
+        # Find the substring "app name is:"
+        start_index = user_input.find("app name is:") + len("app name is:")
+
+        # Find the end of the app name
+        end_index = user_input.find(".", start_index)
+
+        # Extract the app name
+        app_name = user_input[start_index:end_index].strip()
+
+        return app_name
+
+    def extract_app_description(self, user_input: str) -> str:
+        """
+        Extracts the app description from the user's input.
+        """
+
+        # Find the substring "app description is:"
+        start_index = user_input.find("app description is:") + len("app description is:")
+
+        # Find the end of the app description
+        end_index = user_input.find(".", start_index)
+
+        # Extract the app description
+        app_description = user_input[start_index:end_index].strip()
+
+        return app_description
+
+    def extract_app_features(self, user_input: str) -> List[str]:
+        """
+        Extracts the app features from the user's input.
+        """
+
+        # Find the substring "app features are:"
+        start_index = user_input.find("app features are:") + len("app features are:")
+
+        # Find the end of the app features
+        end_index = user_input.find(".", start_index)
+
+        # Extract the app features
+        app_features_str = user_input[start_index:end_index].strip()
+
+        # Split the app features string into a list
+        app_features = app_features_str.split(", ")
+
+        return app_features
+
+    def extract_app_dependencies(self, user_input: str) -> List[str]:
+        """
+        Extracts the app dependencies from the user's input.
+        """
+
+        # Find the substring "app dependencies are:"
+        start_index = user_input.find("app dependencies are:") + len("app dependencies are:")
+
+        # Find the end of the app dependencies
+        end_index = user_input.find(".", start_index)
+
+        # Extract the app dependencies
+        app_dependencies_str = user_input[start_index:end_index].strip()
+
+        # Split the app dependencies string into a list
+        app_dependencies = app_dependencies_str.split(", ")
+
+        return app_dependencies
+
+    def extract_app_space(self, user_input: str) -> Optional[Space]:
+        """
+        Extracts the app space from the user's input.
+        """
+
+        # Find the substring "app space is:"
+        start_index = user_input.find("app space is:") + len("app space is:")
+
+        # Find the end of the app space
+        end_index = user_input.find(".", start_index)
+
+        # Extract the app space
+        app_space_str = user_input[start_index:end_index].strip()
+
+        # Create a Space object
+        app_space = Space(space=app_space_str)
+
+        return app_space
+
+    def extract_app_tutorial(self, user_input: str) -> Optional[Tutorial]:
+        """
+        Extracts the app tutorial from the user's input.
+        """
+
+        # Find the substring "app tutorial is:"
+        start_index = user_input.find("app tutorial is:") + len("app tutorial is:")
+
+        # Find the end of the app tutorial
+        end_index = user_input.find(".", start_index)
+
+        # Extract the app tutorial
+        app_tutorial_str = user_input[start_index:end_index].strip()
+
+        # Create a Tutorial object
+        app_tutorial = Tutorial(tutorial=app_tutorial_str)
+
+        return app_tutorial
+
+    def generate_code(self, prompt: Prompt) -> Code:
+        """
+        Generates code using the Llama model.
+        """
+
+        # Send the prompt to the Llama model
+        response = self.client(prompt.prompt)
+
+        # Extract the generated code
+        code = response["generated_text"]
+        code = code.replace("```", "")
+        code = code.replace("```", "")
+
+        # Create a Code object
+        code = Code(code=code, language="python")
+
+        return code
+
+    def generate_files(self, app_type: AppType, app_name: str, app_description: str, app_features: List[str], app_dependencies: List[str], app_space: Optional[Space] = None, app_tutorial: Optional[Tutorial] = None) -> List[File]:
+        """
+        Generates files for the application.
+        """
+
+        # Generate files based on the app type
+        files = self.prompts["generateFiles"](
+            app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial
         )
 
+        return files
+
+def main():
+    """
+    Main function for the application.
+    """
+
+    # Create an agent
+    agent = Agent(
+        prompts={
+            "createLlamaPrompt": createLlamaPrompt,
+            "createSpace": createSpace,
+            "isPythonOrGradioAppPrompt": isPythonOrGradioAppPrompt,
+            "isReactAppPrompt": isReactAppPrompt,
+            "isStreamlitAppPrompt": isStreamlitAppPrompt,
+            "getWebApp": getWebApp,
+            "getGradioApp": getGradioApp,
+            "getReactApp": getReactApp,
+            "getStreamlitApp": getStreamlitApp,
+            "parseTutorial": parseTutorial,
+            "generateFiles": generateFiles,
+        }
+    )
+
+    # Get user input
+    user_input = input("Enter your request: ")
+
+    # Process the user's input
+    response = agent.process(user_input)
+
+    # Print the response
+    print(response)
 
-    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=1000*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)
-
-# Run the main function if the script is executed directly
 if __name__ == "__main__":
-    main() 
+    main()