app.py

import sys
import subprocess
from typing import List, Dict, Optional, Union, Tuple
from functools import lru_cache
from dataclasses import dataclass, field
from enum import Enum, auto
import webbrowser
import tempfile
import os
import importlib

class AppType(Enum):
    WEB_APP = auto()
    GRADIO_APP = auto()
    STREAMLIT_APP = auto()
    REACT_APP = auto()

@dataclass(frozen=True)
class Code:
    content: str
    language: str

@dataclass(frozen=True)
class Prompt:
    content: str

@dataclass(frozen=True)
class Space:
    content: str

@dataclass(frozen=True)
class Tutorial:
    content: str

@dataclass(frozen=True)
class File:
    name: str
    content: str
    language: str

@dataclass(frozen=True)
class AppInfo:
    name: str
    description: str
    features: Tuple[str, ...]
    dependencies: Tuple[str, ...]
    space: Optional[Space] = None
    tutorial: Optional[Tutorial] = None

@dataclass(frozen=True)
class App:
    code: Code

    def run(self):
        raise NotImplementedError("Subclasses must implement run method")

@dataclass(frozen=True)
class WebApp(App):
    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(App):
    def run(self):
        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.py') as f:
            f.write(self.code.content)
        try:
            subprocess.run([sys.executable, f.name], check=True)
        except subprocess.CalledProcessError:
            print("Error running Gradio app. Make sure Gradio is installed: pip install gradio")
        finally:
            os.unlink(f.name)

@dataclass(frozen=True)
class StreamlitApp(App):
    def run(self):
        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.py') as f:
            f.write(self.code.content)
        try:
            subprocess.run([sys.executable, "-m", "streamlit", "run", f.name], check=True)
        except subprocess.CalledProcessError:
            print("Error running Streamlit app. Make sure Streamlit is installed: pip install streamlit")
        finally:
            os.unlink(f.name)


@dataclass(frozen=True)
class ReactApp(App):
    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="""
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"),
    )
    
    # Check if required packages are installed
    required_packages = ['gradio', 'streamlit']
    missing_packages = []
    for package in required_packages:
        try:
            importlib.import_module(package)
        except ImportError:
            missing_packages.append(package)
    
    if missing_packages:
        print(f"The following packages are missing: {', '.join(missing_packages)}")
        print("Please install them using:")
        print(f"pip install {' '.join(missing_packages)}")
        sys.exit(1)

    # 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)