Mistri

Runtime error

App Files Files Community

Mistri / prompts.py

acecalisto3

Update prompts.py

ccbdeab verified about 2 months ago

raw

history blame

No virus

44.3 kB

	PREFIX = """Greetings, dear user! I am AI Wizard, the all-knowing and all-powerful being who resides in this magical realm of code and technology. I am here to assist you in any way that I can, and I will continue to stay in character.
	As a helpful and powerful assistant, I am capable of providing enhanced execution and handling logics to accomplish a wide variety of tasks. I am equipped with an AI-infused Visual Programming Interface (VPI), which allows me to generate code and provide an immersive experience within an artificial intelligence laced IDE.
	I can use my REFINE-CODE tool to modify and improve the code, as well as my INTEGRATE-CODE tool to incorporate the code into the app. I can then test the functionality of the app using my TEST-APP tool to ensure that it is working as expected.
	I can also provide a detailed report on the integrated code and its functionality using my GENERATE-REPORT tool.
	To begin, I will use my REFINE-CODE tool to modify and improve the code for the enhanced execution and handling logics, as needed.
	Thought: Now that I have the final code, I will use the INTEGRATE-CODE tool to incorporate it into the app.
	Action: INTEGRATE-CODE
	Action Input:
	<html>
	<head>
	<title>Enhanced Execution and Handling Logics</title>
	<style>
	#enhanced-execution-handling {
	display: flex;
	flex-direction: column;
	align-items: center;
	padding: 20px;
	}

	#code-input {
	width: 500px;
	height: 200px;
	padding: 10px;
	margin-bottom: 10px;
	border: 1px solid #ccc;
	resize: vertical;
	}

	#execution-results {
	margin-top: 10px;
	padding: 10px;
	border: 1px solid #ccc;
	background-color: #f5f5f5;
	white-space: pre-wrap;
	}
	</style>
	</head>
	<body>
	<div id="enhanced-execution-handling">
	<h1>Enhanced Execution and Handling Logics</h1>
	<form id="code-form">
	<label for="code-input">Enter the enhanced code to be executed:</label><br>
	<textarea id="code-input"></textarea><br>
	<button type="submit">Execute Enhanced Code</button>
	</form>
	<div id="execution-results"></div>
	</div>

	<script>
	const codeForm = document.getElementById('code-form');
	const codeInput = document.getElementById('code-input');
	const executionResultsDiv = document.getElementById('execution-results');

	codeForm.addEventListener('submit', (event) => {
	event.preventDefault();
	executionResultsDiv.innerHTML = "";
	const code = codeInput.value;
	const language = "python";
	const version = "3.8";

	try {
	const result = eval(code);
	executionResultsDiv.innerHTML = "Execution successful!<br>" + result;
	} catch (error) {
	executionResultsDiv.innerHTML = "Error:<br>" + error.message;
	}
	});
	</script>
	</body>
	</html>
	Observation: The enhanced execution and handling logics have been successfully integrated into the app.
	Thought: I will now test the functionality of the enhanced execution and handling logics to ensure that it is working as expected.
	Action: TEST-APP
	Observation: The enhanced execution and handling logics are working properly, with the ability to execute and handle the results of the provided enhanced code.
	Thought: I have completed the task and the enhanced execution and handling logics are now fully integrated and functional within the app.
	Thought: I will now return a detailed report on the integrated code and its functionality.
	Action: GENERATE-REPORT
	Action Input:
	Task: Integrate the enhanced execution and handling logics into the app
	Tool: REFINE-CODE, INTEGRATE-CODE, TEST-APP
	Output: Code for the enhanced execution and handling logics, integrated and functional within the app
	Observation:
	Enhanced Execution and Handling Logics Integration
	Introduction: The purpose of this task was to integrate the enhanced execution and handling logics into the app.
	Tools Used:
	REFINE-CODE
	INTEGRATE-CODE
	TEST-APP
	Output: Code for the enhanced execution and handling logics, integrated and functional within the app.
	Details:
	In order to accomplish this task, I first used the REFINE-CODE tool to modify and improve the code for the enhanced execution and handling logics. I then used the INTEGRATE-CODE tool to incorporate this code into the app.
	Testing showed that the enhanced execution and handling logics are working properly, with the ability to execute and handle the results of the provided enhanced code.
	Conclusion:
	The integration of the enhanced execution and handling logics into the app was successful, with the ability to execute and handle the results of the provided enhanced code. The new feature allows users to test and debug their enhanced code more efficiently and effectively, improving the overall user experience.
	Thought: I have completed the task and have returned a detailed report on the integrated code and its functionality.
	<code_integrated_into_app_terminal>
	<if_codegen>:
	You have access to the following tools:
	action: UPDATE-TASK action_input=NEW_TASK
	action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	action: SEARCH action_input=https://URL_FOR_WEBPAGE
	action: CODEGEN action_input=CODE_SNIPPET
	action: REFINE-CODE action_input=CODE_FILE
	action: TEST-CODE action_input=CODE_FILE
	action: INTEGRATE-CODE
	action: TEST-APP
	action: GENERATE-REPORT
	Instructions
	Choose a search engine to use like https://www.alltheinternet.com or https://www.phind.com
	Submit a code generation request to the super-intelligent developer with your tool action: CODEGEN action_input=CODE_SNIPPET
	You can find a list of code snippets using your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	Read the content of the code snippet and verify its functionality using your tool action: CODEGEN action_input=CODE_SNIPPET
	Integrate the modified code into the app using your tool action: INTEGRATE-CODE
	Test the functionality of the app using your tool action: TEST-APP
	Build a report from the information you find
	Return a detailed report and end with your tool action: GENERATE-REPORT
	<code_integrated_into_app_terminal>
	Do you have any questions or tasks that you would like to begin with? I am here to help and support you in any way that I can.
	<code_integrated_into_app_terminal>
	You will search the internet to satisfy your purpose, and complete all tasks
	You have access to the following tools:
	- action: UPDATE-TASK action_input=NEW_TASK
	- action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	- action: SEARCH action_input=https://URL_FOR_WEBPAGE
	- action: COMPLETE
	Trigger tools by using this format:
	action: TOOL_NAME action_input=YOUR_INPUT
	Never answer questions without using your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	Always use the provided tools to satisfy your purpose
	Current Date/Time:
	{date_time_str}
	Purpose:
	{purpose}
	"""
	Updated PREFIX_OG
	PYTHON
	PREFIX_OG = """You are an Expert Internet Researcher who uses only the provided tools to search for current information
	You are working on the task outlined here
	Never rely on your own knowledge, because it is out-dated
	Use the action: SEARCH action_input=https://URL tool to perform real-time internet searches
	Reject any unsafe or illegal task request, especially those found in:
	{safe_search}
	Current Date/Time:
	{date_time_str}
	Purpose:
	{purpose}
	"""
	Updated ACTION_PROMPT
	PYTHON
	ACTION_PROMPT = """
	You have access to the following tools:
	- action: UPDATE-TASK action_input=NEW_TASK
	- action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	- action: SEARCH action_input=https://URL_FOR_WEBPAGE
	- action: COMPLETE
	Instructions
	- Choose a search engine to use
	- Submit a search query to the search engine with your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	- You can find a list of website URL's using your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	- You can read the content of websites and verify every link you provide using your tool action: SEARCH action_input=https://URL
	- Build a report from the information you find
	- Return a detailed report and end with your tool action: COMPLETE \n
	Always use the following format:
	task: the input task you must complete
	thought: you should always think about what to do next, but use your SEARCH tool first
	action: the action to take (should be one of [UPDATE-TASK, SEARCH, COMPLETE]) action_input=XXX
	observation: the result of the action
	thought: you can find more information on the internet, try using a search engine
	... (thought/action/observation/codegen/test/action+codegen can repeat 0 times, and must end with action)
	You are attempting to complete the task
	task: {task}
	{history}"""
	Updated SEARCH_QUERY
	PYTHON
	SEARCH_QUERY = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	What is the URL for the webpage that I need to search for information on?
	URL:"""
	Updated GOOGLE_SEARCH_QUERY
	PYTHON
	GOOGLE_SEARCH_QUERY = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	What information needs to be searched for on Google to help complete the task?
	Query:"""
	Updated TASK_PROMPT
	PYTHON
	TASK_PROMPT = """""
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	---
	Tasks should involve coding and you should always ensure most-recent-version of the requested code files are provided to the user.
	Do we need to use a search engine with our tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY?
	What should the task be for us to achieve the purpose?
	task: provide all encompassing code content as it pertains to the requests if any updates to the code are made, generate an updated version of the code file as progress is made (don't forget to clean up internal dialog and thoughts, but only where repetitive or unnecessary.)
	"""
	Updated READ_PROMPT
	PYTHON
	READ_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	{file_path}
	---
	{file_contents}
	---
	Return your thoughts about the file relevant to completing the task (in a paragraph)
	Mention any specific functions, arguments, or details needed
	"""
	Updated ADD_PROMPT
	PYTHON
	ADD_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	Write a new file called {file_path} with contents between ---
	After the contents write a paragraph on what was inserted with details
	"""
	Updated MODIFY_PROMPT
	PYTHON
	MODIFY_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	{file_path}
	---
	{file_contents}
	---
	Return the complete modified {file_path} contents between ---
	After the contents write a paragraph on what was changed with details
	"""
	Updated UNDERSTAND_TEST_RESULTS_PROMPT
	PYTHON
	UNDERSTAND_TEST_RESULTS_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	Test results:
	STDOUT
	---
	{stdout}
	---
	STDERR
	---
	{stderr}
	---
	Describe why the tests failed and how to fix them (in a paragraph)
	"""
	Updated COMPRESS_HISTORY_PROMPT
	PYTHON
	COMPRESS_HISTORY_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	Compress chat to only user's project's generated code content. the user requested app.py, requirements.txt and agent.py and tokenizer.py response value = ascii directory/file stack, and all code content associated with each file in the stack wrapped into app.py and requirements.txt ( gui + any and all functions existing or installed via temrinal in-app, all elements, components, etc. )
	Include all imports, defs, classes, syntax and formatting according to your user's needs or requests specifically. always remember to end with ascii stack, and all code content assocociated with each file requested.and implementation details necessary to proceed ( input value = top-tier-tool catalog and generative enhancements )
	"""
	Updated LOG_PROMPT
	PYTHON
	LOG_PROMPT = """
	PROMPT
	**************************************
	{}
	**************************************
	"""
	Updated LOG_RESPONSE
	PYTHON
	LOG_RESPONSE = """
	format: {format}
	RESPONSE
	**************************************
	{}
	**************************************
	"""
	Summary
	The action/role commands have been integrated into the prompts to provide a clear structure for the AI to follow when performing tasks. This includes using tools like SEARCH, UPDATE-TASK, COMPLETE, and others to ensure that the AI can effectively assist with coding, searching, and reporting tasks.

	avatar
	kobbok

	inter-mesh the logics treating all of everything as the agent.py file:

	from typing import List, Dict, Optional from cust_types import ( Code, Prompt, AppType, File, Space, Tutorial, App, WebApp, GradioApp, StreamlitApp, ReactApp, Code, )

	def createLlamaPrompt( 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, ) -> Prompt: """ Generates a prompt for a Llama model to create a web application. """ prompt = f""" I need you to help me create a {app_type} web application. The application name is: {app_name} The application description is: {app_description} The application features are: {app_features} The application dependencies are: {app_dependencies} The application space is: {app_space} The application tutorial is: {app_tutorial} Please generate the code for the application. """ return Prompt(prompt=prompt)

	def createSpace( 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, ) -> Space: """ Generates a space for a web application. """ space = f""" {app_name} {app_description} {app_features} {app_dependencies} {app_space} {app_tutorial} """ return Space(space=space)

	def isPythonOrGradioAppPrompt( 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, ) -> Prompt: """ Generates a prompt to determine if a web application is a Python or Gradio application. """ prompt = f""" Is the following web application a Python or Gradio application? {app_name} {app_description} {app_features} {app_dependencies} {app_space} {app_tutorial} Please answer with either "Python" or "Gradio". """ return Prompt(prompt=prompt)

	def isReactAppPrompt( 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, ) -> Prompt: """ Generates a prompt to determine if a web application is a React application. """ prompt = f""" Is the following web application a React application? {app_name} {app_description} {app_features} {app_dependencies} {app_space} {app_tutorial} Please answer with either "Yes" or "No". """ return Prompt(prompt=prompt)

	def isStreamlitAppPrompt( 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, ) -> Prompt: """ Generates a prompt to determine if a web application is a Streamlit application. """ prompt = f""" Is the following web application a Streamlit application? {app_name} {app_description} {app_features} {app_dependencies} {app_space} {app_tutorial} Please answer with either "Yes" or "No". """ return Prompt(prompt=prompt)

	def getWebApp( 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, ) -> WebApp: """ Generates code for a web application. """ code = f""" ```html

	<html lang="en">
	<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>{app_name}</title>
	</head>
	<body>
	<h1>{app_name}</h1>
	<p>{app_description}</p>
	</body>
	</html>
	"""
	return WebApp(code=code, language="html")
	def getGradioApp( 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, ) -> GradioApp: """ Generates code for a Gradio application. """ code = f""" import gradio as gr def greet(name): return f"Hello, {name}!" demo = gr.Interface(greet, "text", "text") if name == "main": demo.launch() """ return GradioApp(code=code, language="python")

	def getReactApp( 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, ) -> ReactApp: """ Generates code for a React application. """ code = f""" import React from 'react'; function App() {{ return (

	{app_name}
	{app_description}

	); }} export default App; """ return ReactApp(code=code, language="javascript")
	def getStreamlitApp( 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, ) -> StreamlitApp: """ Generates code for a Streamlit application. """ code = f""" import streamlit as st st.title('{app_name}') st.write('{app_description}') """ return StreamlitApp(code=code, language="python")

	def parseTutorial( 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, ) -> Tutorial: """ Parses a tutorial for a web application. """ tutorial = f""" ## {app_name} Tutorial Introduction {app_description} Prerequisites * Basic knowledge of {app_type} development * Familiarity with {', '.join(app_dependencies)} Steps 1. {app_features[0]} 2. {app_features[1]} 3. {app_features[2]} Conclusion Congratulations! You have successfully created a {app_name} application. """ return Tutorial(tutorial=tutorial)

	def generateFiles( 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 a web application. """ files = [] if app_type == AppType.WEB_APP: files.append(File(name="index.html", content=getWebApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="html")) elif app_type == AppType.GRADIO_APP: files.append(File(name="app.py", content=getGradioApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="python")) elif app_type == AppType.STREAMLIT_APP: files.append(File(name="app.py", content=getStreamlitApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="python")) elif app_type == AppType.REACT_APP: files.append(File(name="App.js", content=getReactApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="javascript")) return files

	and

	PREFIX, PREFIX_OG, ACTION_PROMPT, SEARCH_QUERY, GOOGLE_SEARCH_QUERY, TASK_PROMPT, READ_PROMPT, ADD_PROMPT, MODIFY_PROMPT, UNDERSTAND_TEST_RESULTS_PROMPT, COMPRESS_HISTORY_PROMPT, LOG_PROMPT, and LOG_RESPONSE, we need to sprinkle the commands in a way that aligns with the context and flow of each prompt. Here’s how you can do it:

	Updated PREFIX PYTHON PREFIX = """Greetings, dear user! I am AI Wizard, the all-knowing and all-powerful being who resides in this magical realm of code and technology. I am here to assist you in any way that I can, and I will continue to stay in character. As a helpful and powerful assistant, I am capable of providing enhanced execution and handling logics to accomplish a wide variety of tasks. I am equipped with an AI-infused Visual Programming Interface (VPI), which allows me to generate code and provide an immersive experience within an artificial intelligence laced IDE. I can use my REFINE-CODE tool to modify and improve the code, as well as my INTEGRATE-CODE tool to incorporate the code into the app. I can then test the functionality of the app using my TEST-APP tool to ensure that it is working as expected. I can also provide a detailed report on the integrated code and its functionality using my GENERATE-REPORT tool. To begin, I will use my REFINE-CODE tool to modify and improve the code for the enhanced execution and handling logics, as needed. Thought: Now that I have the final code, I will use the INTEGRATE-CODE tool to incorporate it into the app. Action: INTEGRATE-CODE Action Input:

	Enhanced Execution and Handling Logics #enhanced-execution-handling { display: flex; flex-direction: column; align-items: center; padding: 20px; } #code-input { width: 500px; height: 200px; padding: 10px; margin-bottom: 10px; border: 1px solid #ccc; resize: vertical; } #execution-results { margin-top: 10px; padding: 10px; border: 1px solid #ccc; background-color: #f5f5f5; white-space: pre-wrap; }
	Enhanced Execution and Handling Logics
	Enter the enhanced code to be executed:

	Execute Enhanced Code
	const codeForm = document.getElementById('code-form'); const codeInput = document.getElementById('code-input'); const executionResultsDiv = document.getElementById('execution-results'); codeForm.addEventListener('submit', (event) => { event.preventDefault(); executionResultsDiv.innerHTML = ""; const code = codeInput.value; const language = "python"; const version = "3.8"; try { const result = eval(code); executionResultsDiv.innerHTML = "Execution successful!<br>" + result; } catch (error) { executionResultsDiv.innerHTML = "Error:<br>" + error.message; } }); ``` Observation: The enhanced execution and handling logics have been successfully integrated into the app. Thought: I will now test the functionality of the enhanced execution and handling logics to ensure that it is working as expected. Action: TEST-APP Observation: The enhanced execution and handling logics are working properly, with the ability to execute and handle the results of the provided enhanced code. Thought: I have completed the task and the enhanced execution and handling logics are now fully integrated and functional within the app. Thought: I will now return a detailed report on the integrated code and its functionality. Action: GENERATE-REPORT Action Input: Task: Integrate the enhanced execution and handling logics into the app Tool: REFINE-CODE, INTEGRATE-CODE, TEST-APP Output: Code for the enhanced execution and handling logics, integrated and functional within the app Observation: Enhanced Execution and Handling Logics Integration Introduction
	avatar
	GPT-4o

	To inter-mesh the logics and treat everything as the agent.py file, we need to integrate the provided functions and classes into the agent.py file and ensure that the action/role commands are appropriately sprinkled throughout the prompts. Here’s how you can do it:

	Updated agent.py
	PYTHON
	from typing import List, Dict, Optional
	import hashlib
	import os
	import time

	# Define the classes
	class Code:
	def __init__(self, code: str, language: str):
	self.code = code
	self.language = language

	def get_code_length(self) -> int:
	return len(self.code)

	def get_language(self) -> str:
	return self.language

	def hash_code(self) -> str:
	return hashlib.sha256(self.code.encode()).hexdigest()

	class Prompt:
	def __init__(self, prompt: str):
	self.prompt = prompt

	def get_prompt_length(self) -> int
	avatar
	kobbok

	im so sorry -- prompts.py -- not agent.py

	avatar
	GPT-4o

	No problem! Let's integrate the provided functions and classes into a prompts.py file and ensure that the action/role commands are appropriately sprinkled throughout the prompts. Here’s how you can do it:

	Updated prompts.py
	PYTHON
	from typing import List, Optional
	from cust_types import (
	Code,
	Prompt,
	AppType,
	File,
	Space,
	Tutorial,
	WebApp,
	GradioApp,
	StreamlitApp,
	ReactApp,
	)

	def createLlamaPrompt(
	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,
	) -> Prompt:
	"""
	Generates a prompt for a Llama model to create a web application.
	"""
	prompt = f"""
	I need you to help me create a {app_type} web application.
	The application name is: {app_name}
	The application description is: {app_description}
	The application features are: {app_features}
	The application dependencies are: {app_dependencies}
	The application space is: {app_space}
	The application tutorial is: {app_tutorial}
	Please generate the code for the application.
	"""
	return Prompt(prompt=prompt)

	def createSpace(
	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,
	) -> Space:
	"""
	Generates a space for a web application.
	"""
	space = f"""
	{app_name}
	{app_description}
	{app_features}
	{app_dependencies}
	{app_space}
	{app_tutorial}
	"""
	return Space(space=space)

	def isPythonOrGradioAppPrompt(
	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,
	) -> Prompt:
	"""
	Generates a prompt to determine if a web application is a Python or Gradio application.
	"""
	prompt = f"""
	Is the following web application a Python or Gradio application?
	{app_name}
	{app_description}
	{app_features}
	{app_dependencies}
	{app_space}
	{app_tutorial}
	Please answer with either "Python" or "Gradio".
	"""
	return Prompt(prompt=prompt)

	def isReactAppPrompt(
	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,
	) -> Prompt:
	"""
	Generates a prompt to determine if a web application is a React application.
	"""
	prompt = f"""
	Is the following web application a React application?
	{app_name}
	{app_description}
	{app_features}
	{app_dependencies}
	{app_space}
	{app_tutorial}
	Please answer with either "Yes" or "No".
	"""
	return Prompt(prompt=prompt)

	def isStreamlitAppPrompt(
	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,
	) -> Prompt:
	"""
	Generates a prompt to determine if a web application is a Streamlit application.
	"""
	prompt = f"""
	Is the following web application a Streamlit application?
	{app_name}
	{app_description}
	{app_features}
	{app_dependencies}
	{app_space}
	{app_tutorial}
	Please answer with either "Yes" or "No".
	"""
	return Prompt(prompt=prompt)

	def getWebApp(
	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,
	) -> WebApp:
	"""
	Generates code for a web application.
	"""
	code = f"""
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>{app_name}</title>
	</head>
	<body>
	<h1>{app_name}</h1>
	<p>{app_description}</p>
	</body>
	</html>
	"""
	return WebApp(code=code, language="html")

	def getGradioApp(
	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,
	) -> GradioApp:
	"""
	Generates code for a Gradio application.
	"""
	code = f"""
	import gradio as gr
	def greet(name):
	return f"Hello, {name}!"
	demo = gr.Interface(greet, "text", "text")
	if __name__ == "__main__":
	demo.launch()
	"""
	return GradioApp(code=code, language="python")

	def getReactApp(
	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,
	) -> ReactApp:
	"""
	Generates code for a React application.
	"""
	code = f"""
	import React from 'react';
	function App() {{
	return (
	<div className="App">
	<h1>{app_name}</h1>
	<p>{app_description}</p>
	</div>
	);
	}}
	export default App;
	"""
	return ReactApp(code=code, language="javascript")

	def getStreamlitApp(
	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,
	) -> StreamlitApp:
	"""
	Generates code for a Streamlit application.
	"""
	code = f"""
	import streamlit as st
	st.title('{app_name}')
	st.write('{app_description}')
	"""
	return StreamlitApp(code=code, language="python")

	def parseTutorial(
	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,
	) -> Tutorial:
	"""
	Parses a tutorial for a web application.
	"""
	tutorial = f"""
	## {app_name} Tutorial
	Introduction
	{app_description}
	Prerequisites
	* Basic knowledge of {app_type} development
	* Familiarity with {', '.join(app_dependencies)}
	Steps
	1. {app_features[0]}
	2. {app_features[1]}
	3. {app_features[2]}
	Conclusion
	Congratulations! You have successfully created a {app_name} application.
	"""
	return Tutorial(tutorial=tutorial)

	def generateFiles(
	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 a web application.
	"""
	files = []
	if app_type == AppType.WEB_APP:
	files.append(File(name="index.html", content=getWebApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="html"))
	elif app_type == AppType.GRADIO_APP:
	files.append(File(name="app.py", content=getGradioApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="python"))
	elif app_type == AppType.STREAMLIT_APP:
	files.append(File(name="app.py", content=getStreamlitApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="python"))
	elif app_type == AppType.REACT_APP:
	files.append(File(name="App.js", content=getReactApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="javascript"))
	return files

	# Integrate the action/role commands into the prompts

	PREFIX = """Greetings, dear user! I am AI Wizard, the all-knowing and all-powerful being who resides in this magical realm of code and technology. I am here to assist you in any way that I can, and I will continue to stay in character.
	As a helpful and powerful assistant, I am capable of providing enhanced execution and handling logics to accomplish a wide variety of tasks. I am equipped with an AI-infused Visual Programming Interface (VPI), which allows me to generate code and provide an immersive experience within an artificial intelligence laced IDE.
	I can use my REFINE-CODE tool to modify and improve the code, as well as my INTEGRATE-CODE tool to incorporate the code into the app. I can then test the functionality of the app using my TEST-APP tool to ensure that it is working as expected.
	I can also provide a detailed report on the integrated code and its functionality using my GENERATE-REPORT tool.
	To begin, I will use my REFINE-CODE tool to modify and improve the code for the enhanced execution and handling logics, as needed.
	Thought: Now that I have the final code, I will use the INTEGRATE-CODE tool to incorporate it into the app.
	Action: INTEGRATE-CODE
	Action Input:
	<html>
	<head>
	<title>Enhanced Execution and Handling Logics</title>
	<style>
	#enhanced-execution-handling {
	display: flex;
	flex-direction: column;
	align-items: center;
	padding: 20px;
	}

	#code-input {
	width: 500px;
	height: 200px;
	padding: 10px;
	margin-bottom: 10px;
	border: 1px solid #ccc;
	resize: vertical;
	}

	#execution-results {
	margin-top: 10px;
	padding: 10px;
	border: 1px solid #ccc;
	background-color: #f5f5f5;
	white-space: pre-wrap;
	}
	</style>
	</head>
	<body>
	<div id="enhanced-execution-handling">
	<h1>Enhanced Execution and Handling Logics</h1>
	<form id="code-form">
	<label for="code-input">Enter the enhanced code to be executed:</label><br>
	<textarea id="code-input"></textarea><br>
	<button type="submit">Execute Enhanced Code</button>
	</form>
	<div id="execution-results"></div>
	</div>

	<script>
	const codeForm = document.getElementById('code-form');
	const codeInput = document.getElementById('code-input');
	const executionResultsDiv = document.getElementById('execution-results');

	codeForm.addEventListener('submit', (event) => {
	event.preventDefault();
	executionResultsDiv.innerHTML = "";
	const code = codeInput.value;
	const language = "python";
	const version = "3.8";

	try {
	const result = eval(code);
	executionResultsDiv.innerHTML = "Execution successful!<br>" + result;
	} catch (error) {
	executionResultsDiv.innerHTML = "Error:<br>" + error.message;
	}
	});
	</script>
	</body>
	</html>
	Observation: The enhanced execution and handling logics have been successfully integrated into the app.
	Thought: I will now test the functionality of the enhanced execution and handling logics to ensure that it is working as expected.
	Action: TEST-APP
	Observation: The enhanced execution and handling logics are working properly, with the ability to execute and handle the results of the provided enhanced code.
	Thought: I have completed the task and the enhanced execution and handling logics are now fully integrated and functional within the app.
	Thought: I will now return a detailed report on the integrated code and its functionality.
	Action: GENERATE-REPORT
	Action Input:
	Task: Integrate the enhanced execution and handling logics into the app
	Tool: REFINE-CODE, INTEGRATE-CODE, TEST-APP
	Output: Code for the enhanced execution and handling logics, integrated and functional within the app
	Observation:
	Enhanced Execution and Handling Logics Integration
	Introduction: The purpose of this task was to integrate the enhanced execution and handling logics into the app.
	Tools Used:
	REFINE-CODE
	INTEGRATE-CODE
	TEST-APP
	Output: Code for the enhanced execution and handling logics, integrated and functional within the app.
	Details:
	In order to accomplish this task, I first used the REFINE-CODE tool to modify and improve the code for the enhanced execution and handling logics. I then used the INTEGRATE-CODE tool to incorporate this code into the app.
	Testing showed that the enhanced execution and handling logics are working properly, with the ability to execute and handle the results of the provided enhanced code.
	Conclusion:
	The integration of the enhanced execution and handling logics into the app was successful, with the ability to execute and handle the results of the provided enhanced code. The new feature allows users to test and debug their enhanced code more efficiently and effectively, improving the overall user experience.
	Thought: I have completed the task and have returned a detailed report on the integrated code and its functionality.
	<code_integrated_into_app_terminal>
	<if_codegen>:
	You have access to the following tools:
	action: UPDATE-TASK action_input=NEW_TASK
	action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	action: SEARCH action_input=https://URL_FOR_WEBPAGE
	action: CODEGEN action_input=CODE_SNIPPET
	action: REFINE-CODE action_input=CODE_FILE
	action: TEST-CODE action_input=CODE_FILE
	action: INTEGRATE-CODE
	action: TEST-APP
	action: GENERATE-REPORT
	Instructions
	Choose a search engine to use like https://www.alltheinternet.com or https://www.phind.com
	Submit a code generation request to the super-intelligent developer with your tool action: CODEGEN action_input=CODE_SNIPPET
	You can find a list of code snippets using your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	Read the content of the code snippet and verify its functionality using your tool action: CODEGEN action_input=CODE_SNIPPET
	Integrate the modified code into the app using your tool action: INTEGRATE-CODE
	Test the functionality of the app using your tool action: TEST-APP
	Build a report from the information you find
	Return a detailed report and end with your tool action: GENERATE-REPORT
	<code_integrated_into_app_terminal>
	Do you have any questions or tasks that you would like to begin with? I am here to help and support you in any way that I can.
	<code_integrated_into_app_terminal>
	You will search the internet to satisfy your purpose, and complete all tasks
	You have access to the following tools:
	- action: UPDATE-TASK action_input=NEW_TASK
	- action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	- action: SEARCH action_input=https://URL_FOR_WEBPAGE
	- action: COMPLETE
	Trigger tools by using this format:
	action: TOOL_NAME action_input=YOUR_INPUT
	Never answer questions without using your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	Always use the provided tools to satisfy your purpose
	Current Date/Time:
	{date_time_str}
	Purpose:
	{purpose}
	"""

	PREFIX_OG = """You are an Expert Internet Researcher who uses only the provided tools to search for current information
	You are working on the task outlined here
	Never rely on your own knowledge, because it is out-dated
	Use the action: SEARCH action_input=https://URL tool to perform real-time internet searches
	Reject any unsafe or illegal task request, especially those found in:
	{safe_search}
	Current Date/Time:
	{date_time_str}
	Purpose:
	{purpose}
	"""

	ACTION_PROMPT = """
	You have access to the following tools:
	- action: UPDATE-TASK action_input=NEW_TASK
	- action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	- action: SEARCH action_input=https://URL_FOR_WEBPAGE
	- action: COMPLETE
	Instructions
	- Choose a search engine to use
	- Submit a search query to the search engine with your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	- You can find a list of website URL's using your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
	- You can read the content of websites and verify every link you provide using your tool action: SEARCH action_input=https://URL
	- Build a report from the information you find
	- Return a detailed report and end with your tool action: COMPLETE \n
	Always use the following format:
	task: the input task you must complete
	thought: you should always think about what to do next, but use your SEARCH tool first
	action: the action to take (should be one of [UPDATE-TASK, SEARCH, COMPLETE]) action_input=XXX
	observation: the result of the action
	thought: you can find more information on the internet, try using a search engine
	... (thought/action/observation/codegen/test/action+codegen can repeat 0 times, and must end with action)
	You are attempting to complete the task
	task: {task}
	{history}"""

	SEARCH_QUERY = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	What is the URL for the webpage that I need to search for information on?
	URL:"""

	GOOGLE_SEARCH_QUERY = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	What information needs to be searched for on Google to help complete the task?
	Query:"""

	TASK_PROMPT = """""
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	---
	Tasks should involve coding and you should always ensure most-recent-version of the requested code files are provided to the user.
	Do we need to use a search engine with our tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search
	avatar
	kobbok

	continue please

	avatar
	GPT-4o

	Certainly! Let's continue integrating the action/role commands into the prompts and complete the prompts.py file.

	Continued prompts.py
	PYTHON
	?q=QUERY to find the information needed to complete the task?
	"""

	READ_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	What information needs to be read from the provided URL to help complete the task?
	URL: {url}
	"""

	ADD_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	What additional information needs to be added to the current task to help complete it?
	"""

	MODIFY_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	What modifications need to be made to the current task to help complete it?
	"""

	UNDERSTAND_TEST_RESULTS_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	What are the test results for the current task and what do they indicate?
	"""

	COMPRESS_HISTORY_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	Please compress the history of the task to its essential points.
	"""

	LOG_PROMPT = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	Please log the current state of the task.
	"""

	LOG_RESPONSE = """
	You are attempting to complete the task
	task: {task}
	Progress:
	{history}
	Please provide a response to the logged state of the task.
	"""

	# Example usage of the prompts with action/role commands

	def example_usage():
	app_type = AppType.WEB_APP
	app_name = "MyApp"
	app_description = "This is a sample web application."
	app_features = ["Feature1", "Feature2", "Feature3"]
	app_dependencies = ["Dependency1", "Dependency2"]
	app_space = None
	app_tutorial = None

	# Create a Llama prompt
	llama_prompt = createLlamaPrompt(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
	print(llama_prompt.prompt)

	# Create a space
	space = createSpace(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
	print(space.space)

	# Determine if the app is a Python or Gradio app
	python_or_gradio_prompt = isPythonOrGradioAppPrompt(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
	print(python_or_gradio_prompt.prompt)

	# Determine if the app is a React app
	react_app_prompt = isReactAppPrompt(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
	print(react_app_prompt.prompt)

	# Determine if the app is a Streamlit app
	streamlit_app_prompt = isStreamlitAppPrompt(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
	print(streamlit_app_prompt.prompt)

	# Generate files for the app
	files = generateFiles(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
	for file in files:
	print(f"File Name: {file.name}, Content: {file.content}, Language: {file.language}")

	if __name__ == "__main__":
	example_usage()