PraisonAI 0.0.59rc2__cp312-cp312-manylinux_2_35_x86_64.whl

praisonai/chainlit_ui.py

@@ -0,0 +1,304 @@
+# praisonai/chainlit_ui.py
+from praisonai.agents_generator import AgentsGenerator 
+from praisonai.auto import AutoGenerator 
+import chainlit as cl
+import os
+from chainlit.types import ThreadDict
+from chainlit.input_widget import Select, TextInput
+from typing import Optional
+from dotenv import load_dotenv
+load_dotenv()
+from contextlib import redirect_stdout
+from io import StringIO
+import logging
+logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO').upper(), format='%(asctime)s - %(levelname)s - %(message)s')
+
+framework = "crewai"
+config_list = [
+            {
+                'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4o"),
+                'base_url': os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
+                'api_key': os.environ.get("OPENAI_API_KEY", "")
+            }
+        ]
+agent_file = "test.yaml"
+
+actions=[
+    cl.Action(name="run", value="run", label="✅ Run"),
+    cl.Action(name="modify", value="modify", label="🔧 Modify"),
+]
+
+@cl.action_callback("run")
+async def on_run(action):
+    await main(cl.Message(content=""))
+
+@cl.action_callback("modify")
+async def on_modify(action):
+    await cl.Message(content="Modify the agents and tools from below settings").send()
+    
+
+@cl.set_chat_profiles
+async def set_profiles(current_user: cl.User):
+    return [
+        cl.ChatProfile(
+            name="Auto",
+            markdown_description="Automatically generate agents and tasks based on your input.",
+            starters=[
+                cl.Starter(
+                    label="Create a movie script",
+                    message="Create a movie script about a futuristic society where AI and humans coexist, focusing on the conflict and resolution between them. Start with an intriguing opening scene.",
+                    icon="/public/movie.svg",
+                ),
+                cl.Starter(
+                    label="Design a fantasy world",
+                    message="Design a detailed fantasy world with unique geography, cultures, and magical systems. Start by describing the main continent and its inhabitants.",
+                    icon="/public/fantasy.svg",
+                ),
+                cl.Starter(
+                    label="Write a futuristic political thriller",
+                    message="Write a futuristic political thriller involving a conspiracy within a global government. Start with a high-stakes meeting that sets the plot in motion.",
+                    icon="/public/thriller.svg",
+                ),
+                cl.Starter(
+                    label="Develop a new board game",
+                    message="Develop a new, innovative board game. Describe the game's objective, rules, and unique mechanics. Create a scenario to illustrate gameplay.",
+                    icon="/public/game.svg",
+                ),
+            ]
+        ),
+        cl.ChatProfile(
+            name="Manual",
+            markdown_description="Manually define your agents and tasks using a YAML file.",
+        ),
+    ]
+
+
+@cl.on_chat_start
+async def start_chat():
+    cl.user_session.set(
+        "message_history",
+        [{"role": "system", "content": "You are a helpful assistant."}],
+    )
+    
+    # Create tools.py if it doesn't exist
+    if not os.path.exists("tools.py"):
+        with open("tools.py", "w") as f:
+            f.write("# Add your custom tools here\n")
+    
+    settings = await cl.ChatSettings(
+        [
+            TextInput(id="Model", label="OpenAI - Model", initial=config_list[0]['model']),
+            TextInput(id="BaseUrl", label="OpenAI - Base URL", initial=config_list[0]['base_url']),
+            TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']), 
+            Select(
+                id="Framework",
+                label="Framework",
+                values=["crewai", "autogen"],
+                initial_index=0,
+            ),
+        ]
+    ).send()
+    cl.user_session.set("settings", settings)
+    chat_profile = cl.user_session.get("chat_profile")
+    if chat_profile=="Manual":
+        
+        agent_file = "agents.yaml"
+        full_agent_file_path = os.path.abspath(agent_file)  # Get full path
+        if os.path.exists(full_agent_file_path):
+            with open(full_agent_file_path, 'r') as f:
+                yaml_content = f.read()
+            msg = cl.Message(content=yaml_content, language="yaml")
+            await msg.send()
+            
+                
+        full_tools_file_path = os.path.abspath("tools.py")  # Get full path
+        if os.path.exists(full_tools_file_path):
+            with open(full_tools_file_path, 'r') as f:
+                tools_content = f.read()
+            msg = cl.Message(content=tools_content, language="python")
+            await msg.send()
+
+        settings = await cl.ChatSettings(
+            [
+                TextInput(id="Model", label="OpenAI - Model", initial=config_list[0]['model']),
+                TextInput(id="BaseUrl", label="OpenAI - Base URL", initial=config_list[0]['base_url']),
+                TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']), 
+                Select(
+                    id="Framework",
+                    label="Framework",
+                    values=["crewai", "autogen"],
+                    initial_index=0,
+                ),
+                TextInput(id="agents", label="agents.yaml", initial=yaml_content, multiline=True),
+                TextInput(id="tools", label="tools.py", initial=tools_content, multiline=True),
+            ]
+        ).send()
+        cl.user_session.set("settings", settings)
+        
+        res = await cl.AskActionMessage(
+            content="Pick an action!",
+            actions=actions,
+        ).send()
+        if res and res.get("value") == "modify":
+            await cl.Message(content="Modify the agents and tools from below settings", actions=actions).send()
+        elif res and res.get("value") == "run":
+            await main(cl.Message(content="", actions=actions))
+
+    await on_settings_update(settings)
+    
+@cl.on_settings_update
+async def on_settings_update(settings):
+    """Handle updates to the ChatSettings form."""
+    global config_list, framework
+    config_list[0]['model'] = settings["Model"]
+    config_list[0]['base_url'] = settings["BaseUrl"]
+    config_list[0]['api_key'] = settings["ApiKey"]
+    os.environ["OPENAI_API_KEY"] = config_list[0]['api_key']
+    os.environ["OPENAI_MODEL_NAME"] = config_list[0]['model']
+    os.environ["OPENAI_API_BASE"] = config_list[0]['base_url']
+    framework = settings["Framework"]
+    
+    if "agents" in settings:
+        with open("agents.yaml", "w") as f:
+            f.write(settings["agents"])
+    if "tools" in settings:
+        with open("tools.py", "w") as f:
+            f.write(settings["tools"])
+    
+    print("Settings updated")
+
+@cl.on_chat_resume
+async def on_chat_resume(thread: ThreadDict):
+    message_history = cl.user_session.get("message_history", [])
+    root_messages = [m for m in thread["steps"] if m["parentId"] is None]
+    for message in root_messages:
+        if message["type"] == "user_message":
+            message_history.append({"role": "user", "content": message["output"]})
+        elif message["type"] == "ai_message":
+            message_history.append({"role": "assistant", "content": message["content"]})
+    cl.user_session.set("message_history", message_history)
+
+# @cl.step(type="tool")
+# async def tool(data: Optional[str] = None, language: Optional[str] = None):
+#     return cl.Message(content=data, language=language)
+
+@cl.step(type="tool", show_input=False)
+async def run_agents(agent_file: str, framework: str):
+    """Runs the agents and returns the result."""
+    agents_generator = AgentsGenerator(agent_file, framework, config_list)
+    current_step = cl.context.current_step
+    print("Current Step:", current_step)
+
+    stdout_buffer = StringIO()
+    with redirect_stdout(stdout_buffer):
+        result = agents_generator.generate_crew_and_kickoff()
+        
+    complete_output = stdout_buffer.getvalue()
+
+    async with cl.Step(name="gpt4", type="llm", show_input=True) as step:
+        step.input = ""
+        
+        for line in stdout_buffer.getvalue().splitlines():
+            print(line)
+            await step.stream_token(line)
+            
+        tool_res = await output(complete_output)
+
+    yield result
+
+@cl.step(type="tool", show_input=False, language="yaml")
+async def output(output):
+    return output
+
+@cl.step(type="tool", show_input=False, language="yaml")
+def agent(output):
+    return(f"""
+        Agent Step Completed!
+        Output: {output}
+    """)
+
+@cl.step(type="tool", show_input=False, language="yaml")
+def task(output):
+    return(f"""
+        Task Completed!
+        Task: {output.description}
+        Output: {output.raw_output}
+        {output}
+    """)
+
+@cl.on_message
+async def main(message: cl.Message):
+    """Run PraisonAI with the provided message as the topic."""
+    message_history = cl.user_session.get("message_history")
+    if message_history is None:
+        message_history = []
+        cl.user_session.set("message_history", message_history)
+    message_history.append({"role": "user", "content": message.content})
+    topic = message.content
+    chat_profile = cl.user_session.get("chat_profile")
+
+    if chat_profile == "Auto":
+        agent_file = "agents.yaml"
+        generator = AutoGenerator(topic=topic, agent_file=agent_file, framework=framework, config_list=config_list)
+        await cl.sleep(2)
+        agent_file = generator.generate()
+        agents_generator = AgentsGenerator(
+            agent_file, 
+            framework, 
+            config_list, 
+            # agent_callback=agent,
+            # task_callback=task
+        )
+        # Capture stdout
+        stdout_buffer = StringIO()
+        with redirect_stdout(stdout_buffer):
+            result = agents_generator.generate_crew_and_kickoff()
+            
+        complete_output = stdout_buffer.getvalue()
+        tool_res = await output(complete_output)
+        msg = cl.Message(content=result)
+        await msg.send()
+        message_history.append({"role": "assistant", "content": message.content})
+    else:  # chat_profile == "Manual"
+        agent_file = "agents.yaml"
+        full_agent_file_path = os.path.abspath(agent_file)  # Get full path
+        full_tools_file_path = os.path.abspath("tools.py")  
+        if os.path.exists(full_agent_file_path):
+            with open(full_agent_file_path, 'r') as f:
+                yaml_content = f.read()
+            # tool_res = await tool()
+            msg_agents = cl.Message(content=yaml_content, language="yaml")
+            await msg_agents.send()
+            if os.path.exists(full_tools_file_path):
+                with open(full_tools_file_path, 'r') as f:
+                    tools_content = f.read()
+                msg_tools = cl.Message(content=tools_content, language="python")
+                await msg_tools.send()
+        else:
+            # If the file doesn't exist, follow the same process as "Auto"
+            generator = AutoGenerator(topic=topic, agent_file=agent_file, framework=framework, config_list=config_list)
+            agent_file = generator.generate()
+
+        agents_generator = AgentsGenerator(agent_file, framework, config_list)
+        result = agents_generator.generate_crew_and_kickoff()
+        msg = cl.Message(content=result, actions=actions)
+        await msg.send()
+        message_history.append({"role": "assistant", "content": message.content})
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Get username and password from environment variables
+username = os.getenv("CHAINLIT_USERNAME", "admin")  # Default to "admin" if not found
+password = os.getenv("CHAINLIT_PASSWORD", "admin")  # Default to "admin" if not found
+
+@cl.password_auth_callback
+def auth_callback(username: str, password: str):
+    # Fetch the user matching username from your database
+    # and compare the hashed password with the value stored in the database
+    if (username, password) == (username, password):
+        return cl.User(
+            identifier=username, metadata={"role": "ADMIN", "provider": "credentials"}
+        )
+    else:
+        return None

praisonai/cli.py

@@ -0,0 +1,337 @@
+# praisonai/cli.py
+
+import sys
+from .version import __version__
+import yaml, os
+from rich import print
+from dotenv import load_dotenv
+from crewai import Agent, Task, Crew
+load_dotenv()
+import autogen
+import argparse
+from .auto import AutoGenerator
+from .agents_generator import AgentsGenerator
+from .inbuilt_tools import *
+import shutil
+import logging
+logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO'), format='%(asctime)s - %(levelname)s - %(message)s')
+
+try:
+    from chainlit.cli import chainlit_run
+    CHAINLIT_AVAILABLE = True
+except ImportError:
+    CHAINLIT_AVAILABLE = False
+
+try:
+    import gradio as gr
+    GRADIO_AVAILABLE = True
+except ImportError:
+    GRADIO_AVAILABLE = False
+
+class PraisonAI:
+    def __init__(self, agent_file="agents.yaml", framework="", auto=False, init=False, agent_yaml=None):
+        """
+        Initialize the PraisonAI object with default parameters.
+
+        Parameters:
+            agent_file (str): The default agent file to use. Defaults to "agents.yaml".
+            framework (str): The default framework to use. Defaults to "crewai".
+            auto (bool): A flag indicating whether to enable auto mode. Defaults to False.
+            init (bool): A flag indicating whether to enable initialization mode. Defaults to False.
+
+        Attributes:
+            config_list (list): A list of configuration dictionaries for the OpenAI API.
+            agent_file (str): The agent file to use.
+            framework (str): The framework to use.
+            auto (bool): A flag indicating whether to enable auto mode.
+            init (bool): A flag indicating whether to enable initialization mode.
+            agent_yaml (str, optional): The content of the YAML file. Defaults to None.
+        """
+        self.agent_yaml = agent_yaml
+        self.config_list = [
+            {
+                'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4o"),
+                'base_url': os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
+                'api_key': os.environ.get("OPENAI_API_KEY")
+            }
+        ]
+        self.agent_file = agent_file
+        self.framework = framework
+        self.auto = auto
+        self.init = init
+
+    def run(self):
+        """
+        Run the PraisonAI application.
+        """
+        self.main()
+
+    def main(self):
+        """
+        The main function of the PraisonAI object. It parses the command-line arguments,
+        initializes the necessary attributes, and then calls the appropriate methods based on the
+        provided arguments.
+
+        Args:
+            self (PraisonAI): An instance of the PraisonAI class.
+    
+        Returns:
+            Any: Depending on the arguments provided, the function may return a result from the
+            AgentsGenerator, a deployment result from the CloudDeployer, or a message indicating
+            the successful creation of a file.
+        """
+        args = self.parse_args()
+        if args is None:
+            agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list)
+            result = agents_generator.generate_crew_and_kickoff()
+            return result
+        if args.deploy:
+            from .deploy import CloudDeployer
+            deployer = CloudDeployer()
+            deployer.run_commands()
+            return
+        
+        if getattr(args, 'chat', False):
+            self.create_chainlit_chat_interface()
+            return
+        
+        if getattr(args, 'code', False):
+            self.create_code_interface()
+            return
+
+        if args.agent_file == 'train':
+            from .train import main as train_main
+            train_args = sys.argv[2:]  # Get all arguments after 'train'
+            train_main(train_args)  # Pass the arguments to train.py's main function
+            return 
+        
+        invocation_cmd = "praisonai"
+        version_string = f"PraisonAI version {__version__}"
+        
+        self.framework = args.framework or self.framework 
+        
+        if args.agent_file:
+            if args.agent_file.startswith("tests.test"): # Argument used for testing purposes. eg: python -m unittest tests.test 
+                print("test")
+            else:
+                self.agent_file = args.agent_file
+        
+        
+        if args.auto or args.init:
+            temp_topic = ' '.join(args.auto) if args.auto else ' '.join(args.init)
+            self.topic = temp_topic
+        elif self.auto or self.init:  # Use the auto attribute if args.auto is not provided
+            self.topic = self.auto
+            
+        if args.auto or self.auto:
+            self.agent_file = "test.yaml"
+            generator = AutoGenerator(topic=self.topic , framework=self.framework, agent_file=self.agent_file)
+            self.agent_file = generator.generate()
+            agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list)
+            result = agents_generator.generate_crew_and_kickoff()
+            return result
+        elif args.init or self.init:
+            self.agent_file = "agents.yaml"
+            generator = AutoGenerator(topic=self.topic , framework=self.framework, agent_file=self.agent_file)
+            self.agent_file = generator.generate()
+            print("File {} created successfully".format(self.agent_file))
+            return "File {} created successfully".format(self.agent_file)
+        
+        if args.ui:
+            if args.ui == "gradio":
+                self.create_gradio_interface()
+            elif args.ui == "chainlit":
+                self.create_chainlit_interface()
+            else:
+                # Modify below code to allow default ui
+                agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list, agent_yaml=self.agent_yaml)
+                result = agents_generator.generate_crew_and_kickoff()
+                return result
+        else:
+            agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list, agent_yaml=self.agent_yaml)
+            result = agents_generator.generate_crew_and_kickoff()
+            return result
+            
+    def parse_args(self):
+        """
+        Parse the command-line arguments for the PraisonAI CLI.
+
+        Args:
+            self (PraisonAI): An instance of the PraisonAI class.
+
+        Returns:
+            argparse.Namespace: An object containing the parsed command-line arguments.
+
+        Raises:
+            argparse.ArgumentError: If the arguments provided are invalid.
+
+        Example:
+            >>> args = praison_ai.parse_args()
+            >>> print(args.agent_file)  # Output: 'agents.yaml'
+        """
+        parser = argparse.ArgumentParser(prog="praisonai", description="praisonAI command-line interface")
+        parser.add_argument("--framework", choices=["crewai", "autogen"], help="Specify the framework")
+        parser.add_argument("--ui", choices=["chainlit", "gradio"], help="Specify the UI framework (gradio or chainlit).")
+        parser.add_argument("--auto", nargs=argparse.REMAINDER, help="Enable auto mode and pass arguments for it")
+        parser.add_argument("--init", nargs=argparse.REMAINDER, help="Enable auto mode and pass arguments for it")
+        parser.add_argument("agent_file", nargs="?", help="Specify the agent file")
+        parser.add_argument("--deploy", action="store_true", help="Deploy the application")  # New argument
+        args, unknown_args = parser.parse_known_args()
+
+        if unknown_args and unknown_args[0] == '-b' and unknown_args[1] == 'api:app':
+            args.agent_file = 'agents.yaml'
+        if args.agent_file == 'api:app' or args.agent_file == '/app/api:app':
+            args.agent_file = 'agents.yaml'
+        if args.agent_file == 'ui':
+            args.ui = 'chainlit'
+        if args.agent_file == 'chat':
+            args.ui = 'chainlit'
+            args.chat = True
+        if args.agent_file == 'code':
+            args.ui = 'chainlit'
+            args.code = True
+
+        return args
+    
+    def create_chainlit_chat_interface(self):
+        """
+        Create a Chainlit interface for the chat application.
+
+        This function sets up a Chainlit application that listens for messages.
+        When a message is received, it runs PraisonAI with the provided message as the topic.
+        The generated agents are then used to perform tasks.
+
+        Returns:
+            None: This function does not return any value. It starts the Chainlit application.
+        """
+        if CHAINLIT_AVAILABLE:
+            import praisonai
+            os.environ["CHAINLIT_PORT"] = "8084"
+            public_folder = os.path.join(os.path.dirname(praisonai.__file__), 'public')
+            if not os.path.exists("public"):  # Check if the folder exists in the current directory
+                if os.path.exists(public_folder):
+                    shutil.copytree(public_folder, 'public', dirs_exist_ok=True)
+                    logging.info("Public folder copied successfully!")
+                else:
+                    logging.info("Public folder not found in the package.")
+            else:
+                logging.info("Public folder already exists.")
+            chat_ui_path = os.path.join(os.path.dirname(praisonai.__file__), 'ui', 'chat.py')
+            chainlit_run([chat_ui_path])
+        else:
+            print("ERROR: Chat UI is not installed. Please install it with 'pip install \"praisonai\[chat]\"' to use the chat UI.")
+            
+    def create_code_interface(self):
+        """
+        Create a Chainlit interface for the code application.
+
+        This function sets up a Chainlit application that listens for messages.
+        When a message is received, it runs PraisonAI with the provided message as the topic.
+        The generated agents are then used to perform tasks.
+
+        Returns:
+            None: This function does not return any value. It starts the Chainlit application.
+        """
+        if CHAINLIT_AVAILABLE:
+            import praisonai
+            os.environ["CHAINLIT_PORT"] = "8086"
+            public_folder = os.path.join(os.path.dirname(praisonai.__file__), 'public')
+            if not os.path.exists("public"):  # Check if the folder exists in the current directory
+                if os.path.exists(public_folder):
+                    shutil.copytree(public_folder, 'public', dirs_exist_ok=True)
+                    logging.info("Public folder copied successfully!")
+                else:
+                    logging.info("Public folder not found in the package.")
+            else:
+                logging.info("Public folder already exists.")
+            code_ui_path = os.path.join(os.path.dirname(praisonai.__file__), 'ui', 'code.py')
+            chainlit_run([code_ui_path])
+        else:
+            print("ERROR: Code UI is not installed. Please install it with 'pip install \"praisonai\[code]\"' to use the code UI.")
+
+    def create_gradio_interface(self):
+        """
+        Create a Gradio interface for generating agents and performing tasks.
+
+        Args:
+            self (PraisonAI): An instance of the PraisonAI class.
+
+        Returns:
+            None: This method does not return any value. It launches the Gradio interface.
+
+        Raises:
+            None: This method does not raise any exceptions.
+
+        Example:
+            >>> praison_ai.create_gradio_interface()
+        """
+        if GRADIO_AVAILABLE:
+            def generate_crew_and_kickoff_interface(auto_args, framework):
+                """
+                Generate a crew and kick off tasks based on the provided auto arguments and framework.
+
+                Args:
+                    auto_args (list): Topic.
+                    framework (str): The framework to use for generating agents.
+
+                Returns:
+                    str: A string representing the result of generating the crew and kicking off tasks.
+
+                Raises:
+                    None: This method does not raise any exceptions.
+
+                Example:
+                    >>> result = generate_crew_and_kickoff_interface("Create a movie about Cat in Mars", "crewai")
+                    >>> print(result)
+                """
+                self.framework = framework
+                self.agent_file = "test.yaml"
+                generator = AutoGenerator(topic=auto_args , framework=self.framework)
+                self.agent_file = generator.generate()
+                agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list)
+                result = agents_generator.generate_crew_and_kickoff()
+                return result
+
+            gr.Interface(
+                fn=generate_crew_and_kickoff_interface,
+                inputs=[gr.Textbox(lines=2, label="Auto Args"), gr.Dropdown(choices=["crewai", "autogen"], label="Framework")],
+                outputs="textbox",
+                title="Praison AI Studio",
+                description="Create Agents and perform tasks",
+                theme="default"
+            ).launch()
+        else:
+            print("ERROR: Gradio is not installed. Please install it with 'pip install gradio' to use this feature.") 
+        
+    def create_chainlit_interface(self):
+        """
+        Create a Chainlit interface for generating agents and performing tasks.
+
+        This function sets up a Chainlit application that listens for messages.
+        When a message is received, it runs PraisonAI with the provided message as the topic.
+        The generated agents are then used to perform tasks.
+
+        Returns:
+            None: This function does not return any value. It starts the Chainlit application.
+        """
+        if CHAINLIT_AVAILABLE:
+            import praisonai
+            os.environ["CHAINLIT_PORT"] = "8082"
+            # Get the path to the 'public' folder within the package
+            public_folder = os.path.join(os.path.dirname(praisonai.__file__), 'public')
+            if not os.path.exists("public"):  # Check if the folder exists in the current directory
+                if os.path.exists(public_folder):
+                    shutil.copytree(public_folder, 'public', dirs_exist_ok=True)
+                    logging.info("Public folder copied successfully!")
+                else:
+                    logging.info("Public folder not found in the package.")
+            else:
+                logging.info("Public folder already exists.")
+            chainlit_ui_path = os.path.join(os.path.dirname(praisonai.__file__), 'chainlit_ui.py')
+            chainlit_run([chainlit_ui_path])
+        else:
+            print("ERROR: Chainlit is not installed. Please install it with 'pip install \"praisonai\[ui]\"' to use the UI.")        
+
+if __name__ == "__main__":
+    praison_ai = PraisonAI()
+    praison_ai.main()