import sys
import subprocess
from typing import List, Dict, Optional, Union
from functools import lru_cache
from dataclasses import dataclass, field
from enum import Enum, auto
import webbrowser
import tempfile
import os
@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"""
{app_info.name}
{app_info.name}
{app_info.description}
""",
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 (
{app_info.name}
{app_info.description}
);
}}
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)
# Create and display info for a ReactApp
react_app = AppFactory.get_app(AppType.REACT_APP, app_info)
AppFactory.run_app(react_app)