Spaces:
Runtime error
Runtime error
| from typing import List, Dict, Optional | |
| from types import ( | |
| Code, | |
| Prompt, | |
| AppType, | |
| File, | |
| Space, | |
| Tutorial, | |
| App, | |
| WebApp, | |
| GradioApp, | |
| StreamlitApp, | |
| ReactApp, | |
| Code, | |
| ) | |
| from agent import Agent | |
| # Import the translated functions from the .py files | |
| from alpine import alpine | |
| from createLlamaPrompt import createLlamaPrompt | |
| from createSpace import createSpace | |
| from daisy import daisy | |
| from docker import docker | |
| from generateFiles import generateFiles | |
| from getGradioApp import getGradioApp | |
| from getReactApp import getReactApp | |
| from getStreamlitApp import getStreamlitApp | |
| from getWebApp import getWebApp | |
| from gradioDoc import gradioDoc | |
| from index import index | |
| from isPythonOrGradioAppPrompt import isPythonOrGradioAppPrompt | |
| from isReactAppPrompt import isReactAppPrompt | |
| from isStreamlitAppPrompt import isStreamlitAppPrompt | |
| from main import main | |
| from parseTutorial import parseTutorial | |
| from streamlitDoc import streamlitDoc | |
| from types import AppType | |
| from typescript import typescript | |
| class Agent: | |
| def __init__(self, prompts: Dict[str, any]): | |
| self.prompts = prompts | |
| self.client = InferenceClient( | |
| "mistralai/Mixtral-8x7B-Instruct-v0.1" | |
| ) | |
| def process(self, user_input: str) -> str: | |
| """ | |
| Processes the user's input and generates code. | |
| """ | |
| # Parse the user's input | |
| app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial = self.parse_input(user_input) | |
| # 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 | |
| ) | |
| # Generate code using the Llama model | |
| code = self.generate_code(prompt) | |
| # Generate files for the application | |
| files = self.prompts["generateFiles"]( | |
| app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial | |
| ) | |
| # Return the generated code and files | |
| return f"Code: {code}\nFiles: {files}" | |
| def parse_input(self, user_input: str) -> tuple: | |
| """ | |
| Parses the user's input and extracts the relevant information. | |
| """ | |
| # Extract the app type | |
| app_type = self.extract_app_type(user_input) | |
| # Extract the app name | |
| app_name = self.extract_app_name(user_input) | |
| # Extract the app description | |
| app_description = self.extract_app_description(user_input) | |
| # Extract the app features | |
| app_features = self.extract_app_features(user_input) | |
| # Extract the app dependencies | |
| app_dependencies = self.extract_app_dependencies(user_input) | |
| # Extract the app space | |
| app_space = self.extract_app_space(user_input) | |
| # Extract the app tutorial | |
| app_tutorial = self.extract_app_tutorial(user_input) | |
| return app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial | |
| def extract_app_type(self, user_input: str) -> AppType: | |
| """ | |
| Extracts the app type from the user's input. | |
| """ | |
| # 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 | |
| # 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) | |
| if __name__ == "__main__": | |
| main() |