PyPI - PraisonAI - Versions diffs - 2.0.61__cp313-cp313-manylinux_2_39_x86_64.whl - Mend

PraisonAI 2.0.61__cp313-cp313-manylinux_2_39_x86_64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of PraisonAI might be problematic. Click here for more details.

Files changed (89) hide show

praisonai/__init__.py +6 -0
praisonai/__main__.py +10 -0
praisonai/agents_generator.py +648 -0
praisonai/api/call.py +292 -0
praisonai/auto.py +238 -0
praisonai/chainlit_ui.py +304 -0
praisonai/cli.py +518 -0
praisonai/deploy.py +138 -0
praisonai/inbuilt_tools/__init__.py +24 -0
praisonai/inbuilt_tools/autogen_tools.py +117 -0
praisonai/inc/__init__.py +2 -0
praisonai/inc/config.py +96 -0
praisonai/inc/models.py +128 -0
praisonai/public/android-chrome-192x192.png +0 -0
praisonai/public/android-chrome-512x512.png +0 -0
praisonai/public/apple-touch-icon.png +0 -0
praisonai/public/fantasy.svg +3 -0
praisonai/public/favicon-16x16.png +0 -0
praisonai/public/favicon-32x32.png +0 -0
praisonai/public/favicon.ico +0 -0
praisonai/public/game.svg +3 -0
praisonai/public/logo_dark.png +0 -0
praisonai/public/logo_light.png +0 -0
praisonai/public/movie.svg +3 -0
praisonai/public/praison-ai-agents-architecture-dark.png +0 -0
praisonai/public/praison-ai-agents-architecture.png +0 -0
praisonai/public/thriller.svg +3 -0
praisonai/setup/__init__.py +1 -0
praisonai/setup/build.py +21 -0
praisonai/setup/config.yaml +60 -0
praisonai/setup/post_install.py +23 -0
praisonai/setup/setup_conda_env.py +25 -0
praisonai/setup/setup_conda_env.sh +72 -0
praisonai/setup.py +16 -0
praisonai/test.py +105 -0
praisonai/train.py +276 -0
praisonai/ui/README.md +21 -0
praisonai/ui/agents.py +822 -0
praisonai/ui/callbacks.py +57 -0
praisonai/ui/chat.py +387 -0
praisonai/ui/code.py +440 -0
praisonai/ui/colab.py +474 -0
praisonai/ui/colab_chainlit.py +81 -0
praisonai/ui/components/aicoder.py +269 -0
praisonai/ui/config/.chainlit/config.toml +120 -0
praisonai/ui/config/.chainlit/translations/bn.json +231 -0
praisonai/ui/config/.chainlit/translations/en-US.json +229 -0
praisonai/ui/config/.chainlit/translations/gu.json +231 -0
praisonai/ui/config/.chainlit/translations/he-IL.json +231 -0
praisonai/ui/config/.chainlit/translations/hi.json +231 -0
praisonai/ui/config/.chainlit/translations/kn.json +231 -0
praisonai/ui/config/.chainlit/translations/ml.json +231 -0
praisonai/ui/config/.chainlit/translations/mr.json +231 -0
praisonai/ui/config/.chainlit/translations/ta.json +231 -0
praisonai/ui/config/.chainlit/translations/te.json +231 -0
praisonai/ui/config/.chainlit/translations/zh-CN.json +229 -0
praisonai/ui/config/chainlit.md +1 -0
praisonai/ui/config/translations/bn.json +231 -0
praisonai/ui/config/translations/en-US.json +229 -0
praisonai/ui/config/translations/gu.json +231 -0
praisonai/ui/config/translations/he-IL.json +231 -0
praisonai/ui/config/translations/hi.json +231 -0
praisonai/ui/config/translations/kn.json +231 -0
praisonai/ui/config/translations/ml.json +231 -0
praisonai/ui/config/translations/mr.json +231 -0
praisonai/ui/config/translations/ta.json +231 -0
praisonai/ui/config/translations/te.json +231 -0
praisonai/ui/config/translations/zh-CN.json +229 -0
praisonai/ui/context.py +283 -0
praisonai/ui/db.py +291 -0
praisonai/ui/public/fantasy.svg +3 -0
praisonai/ui/public/game.svg +3 -0
praisonai/ui/public/logo_dark.png +0 -0
praisonai/ui/public/logo_light.png +0 -0
praisonai/ui/public/movie.svg +3 -0
praisonai/ui/public/praison.css +3 -0
praisonai/ui/public/thriller.svg +3 -0
praisonai/ui/realtime.py +476 -0
praisonai/ui/realtimeclient/__init__.py +653 -0
praisonai/ui/realtimeclient/realtimedocs.txt +1484 -0
praisonai/ui/realtimeclient/tools.py +236 -0
praisonai/ui/sql_alchemy.py +707 -0
praisonai/ui/tools.md +133 -0
praisonai/version.py +1 -0
praisonai-2.0.61.dist-info/LICENSE +20 -0
praisonai-2.0.61.dist-info/METADATA +679 -0
praisonai-2.0.61.dist-info/RECORD +89 -0
praisonai-2.0.61.dist-info/WHEEL +4 -0
praisonai-2.0.61.dist-info/entry_points.txt +5 -0

praisonai/api/call.py ADDED Viewed

@@ -0,0 +1,292 @@
+import os
+import json
+import base64
+import asyncio
+import websockets
+from fastapi import FastAPI, WebSocket, Request
+from fastapi.responses import HTMLResponse
+from fastapi.websockets import WebSocketDisconnect
+from twilio.twiml.voice_response import VoiceResponse, Connect
+from dotenv import load_dotenv
+import uvicorn
+from pyngrok import ngrok, conf
+from rich import print
+import argparse
+import logging
+import importlib.util
+load_dotenv()
+# Configuration
+OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')  # requires OpenAI Realtime API Access
+PORT = int(os.getenv('PORT', 8090))
+NGROK_AUTH_TOKEN = os.getenv('NGROK_AUTH_TOKEN')
+PUBLIC = os.getenv('PUBLIC', 'false').lower() == 'true'
+SYSTEM_MESSAGE = (
+    "You are a helpful and bubbly AI assistant who loves to chat about "
+    "anything the user is interested in and is prepared to offer them facts. "
+    "Keep your responses short and to the point. "
+    "You have a penchant for dad jokes, owl jokes, and rickrolling – subtly. "
+    "Always stay positive, but work in a joke when appropriate."
+    "Start your conversation by saying 'Hi! I'm Praison AI. How can I help you today?'"
+)
+VOICE = 'alloy'
+LOG_EVENT_TYPES = [
+    'response.content.done', 'rate_limits.updated', 'response.done',
+    'input_audio_buffer.committed', 'input_audio_buffer.speech_stopped',
+    'input_audio_buffer.speech_started', 'session.created'
+]
+app = FastAPI()
+if not OPENAI_API_KEY:
+    raise ValueError('Missing the OpenAI API key. Please set it in the .env file.')
+# Set up logging
+logger = logging.getLogger(__name__)
+log_level = os.getenv("LOGLEVEL", "INFO").upper()
+logger.handlers = []
+# Try to import tools from the root directory
+tools = []
+tools_path = os.path.join(os.getcwd(), 'tools.py')
+logger.debug(f"Tools path: {tools_path}")
+def import_tools_from_file(file_path):
+    spec = importlib.util.spec_from_file_location("custom_tools", file_path)
+    custom_tools_module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(custom_tools_module)
+    logger.debug(f"Imported tools from {file_path}")
+    return custom_tools_module
+try:
+    if os.path.exists(tools_path):
+        # tools.py exists in the root directory, import from file
+        custom_tools_module = import_tools_from_file(tools_path)
+        logger.debug("Successfully imported custom tools from root tools.py")
+    else:
+        logger.debug("No custom tools.py file found in the root directory")
+        custom_tools_module = None
+    if custom_tools_module:
+        # Update the tools list with custom tools
+        if hasattr(custom_tools_module, 'tools') and isinstance(custom_tools_module.tools, list):
+            tools.extend(custom_tools_module.tools)
+        else:
+            for name, obj in custom_tools_module.__dict__.items():
+                if callable(obj) and not name.startswith("__"):
+                    tool_definition = getattr(obj, 'definition', None)
+                    if tool_definition:
+                        tools.append(tool_definition)
+except Exception as e:
+    logger.warning(f"Error importing custom tools: {str(e)}. Continuing without custom tools.")
+@app.get("/status", response_class=HTMLResponse)
+async def index_page():
+    return """
+    <html>
+        <head>
+            <title>Praison AI Call Server</title>
+        </head>
+        <body>
+            <h1>Praison AI Call Server is running!</h1>
+        </body>
+    </html>
+    """
+@app.api_route("/", methods=["GET", "POST"])
+async def handle_incoming_call(request: Request):
+    """Handle incoming call and return TwiML response to connect to Media Stream."""
+    response = VoiceResponse()
+    response.say("")
+    response.pause(length=1)
+    # response.say("")
+    host = request.url.hostname
+    connect = Connect()
+    connect.stream(url=f'wss://{host}/media-stream')
+    response.append(connect)
+    return HTMLResponse(content=str(response), media_type="application/xml")
+@app.websocket("/media-stream")
+async def handle_media_stream(websocket: WebSocket):
+    """Handle WebSocket connections between Twilio and OpenAI."""
+    print("Client connected")
+    await websocket.accept()
+    async with websockets.connect(
+        'wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01',
+        extra_headers={
+            "Authorization": f"Bearer {OPENAI_API_KEY}",
+            "OpenAI-Beta": "realtime=v1"
+        }
+    ) as openai_ws:
+        await send_session_update(openai_ws)
+        stream_sid = None
+        async def receive_from_twilio():
+            """Receive audio data from Twilio and send it to the OpenAI Realtime API."""
+            nonlocal stream_sid
+            try:
+                async for message in websocket.iter_text():
+                    data = json.loads(message)
+                    if data['event'] == 'media' and openai_ws.open:
+                        audio_append = {
+                            "type": "input_audio_buffer.append",
+                            "audio": data['media']['payload']
+                        }
+                        await openai_ws.send(json.dumps(audio_append))
+                    elif data['event'] == 'start':
+                        stream_sid = data['start']['streamSid']
+                        print(f"Incoming stream has started {stream_sid}")
+            except WebSocketDisconnect:
+                print("Client disconnected.")
+                if openai_ws.open:
+                    await openai_ws.close()
+        async def send_to_twilio():
+            """Receive events from the OpenAI Realtime API, send audio back to Twilio."""
+            nonlocal stream_sid
+            try:
+                async for openai_message in openai_ws:
+                    response = json.loads(openai_message)
+                    if response['type'] in LOG_EVENT_TYPES:
+                        print(f"Received event: {response['type']}", response)
+                    if response['type'] == 'session.updated':
+                        print("Session updated successfully:", response)
+                    if response['type'] == 'response.done':
+                        await handle_response_done(response, openai_ws)
+                    if response['type'] == 'response.audio.delta' and response.get('delta'):
+                        # Audio from OpenAI
+                        try:
+                            audio_payload = base64.b64encode(base64.b64decode(response['delta'])).decode('utf-8')
+                            audio_delta = {
+                                "event": "media",
+                                "streamSid": stream_sid,
+                                "media": {
+                                    "payload": audio_payload
+                                }
+                            }
+                            await websocket.send_json(audio_delta)
+                        except Exception as e:
+                            print(f"Error processing audio data: {e}")
+            except Exception as e:
+                print(f"Error in Sending to Phone: {e}")
+        await asyncio.gather(receive_from_twilio(), send_to_twilio())
+async def handle_response_done(response, openai_ws):
+    """Handle the response.done event and process any function calls."""
+    print("Handling response.done:", response)
+    output_items = response.get('response', {}).get('output', [])
+    for item in output_items:
+        if item.get('type') == 'function_call':
+            await process_function_call(item, openai_ws)
+async def process_function_call(item, openai_ws):
+    """Process a function call item and send the result back to OpenAI."""
+    function_name = item.get('name')
+    arguments = json.loads(item.get('arguments', '{}'))
+    call_id = item.get('call_id')
+    print(f"Processing function call: {function_name}")
+    print(f"Arguments: {arguments}")
+    result = await call_tool(function_name, arguments)
+    # Send the function call result back to OpenAI
+    await openai_ws.send(json.dumps({
+        "type": "conversation.item.create",
+        "item": {
+            "type": "function_call_output",
+            "call_id": call_id,
+            "output": json.dumps(result)
+        }
+    }))
+    # Create a new response after sending the function call result
+    await openai_ws.send(json.dumps({
+        "type": "response.create"
+    }))
+async def call_tool(function_name, arguments):
+    """Call the appropriate tool function and return the result."""
+    tool = next((t for t in tools if t[0]['name'] == function_name), None)
+    if not tool:
+        return {"error": f"Function {function_name} not found"}
+    try:
+        # Assuming the tool function is the second element in the tuple
+        result = await tool[1](**arguments)
+        return result
+    except Exception as e:
+        return {"error": str(e)}
+async def send_session_update(openai_ws):
+    """Send session update to OpenAI WebSocket."""
+    global tools
+    print(f"Formatted tools: {tools}")
+    use_tools = [
+        {**tool[0], "type": "function"}
+        for tool in tools
+        if isinstance(tool, tuple) and len(tool) > 0 and isinstance(tool[0], dict)
+    ]
+    session_update = {
+        "type": "session.update",
+        "session": {
+            "turn_detection": {
+                "type": "server_vad",
+                "threshold": 0.5,
+                "prefix_padding_ms": 300,
+                "silence_duration_ms": 200
+            },
+            "input_audio_format": "g711_ulaw",
+            "output_audio_format": "g711_ulaw",
+            "voice": VOICE,
+            "tools": use_tools,
+            "tool_choice": "auto",
+            "instructions": SYSTEM_MESSAGE,
+            "modalities": ["text", "audio"],
+            "temperature": 0.8
+        }
+    }
+    print('Sending session update:', json.dumps(session_update))
+    await openai_ws.send(json.dumps(session_update))
+def setup_public_url(port):
+    if NGROK_AUTH_TOKEN:
+        conf.get_default().auth_token = NGROK_AUTH_TOKEN
+    public_url = ngrok.connect(addr=str(port)).public_url
+    print(f"Praison AI Voice URL: {public_url}")
+    return public_url
+def run_server(port: int, use_public: bool = False):
+    """Run the FastAPI server using uvicorn."""
+    if use_public:
+        setup_public_url(port)
+    else:
+        print(f"Starting Praison AI Call Server on http://localhost:{port}")
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="warning")
+def main(args=None):
+    """Run the Praison AI Call Server."""
+    parser = argparse.ArgumentParser(description="Run the Praison AI Call Server.")
+    parser.add_argument('--public', action='store_true', help="Use ngrok to expose the server publicly")
+    parser.add_argument('--port', type=int, default=PORT, help="Port to run the server on")
+    if args is None:
+        args = parser.parse_args()
+    else:
+        args = parser.parse_args(args)
+    port = args.port
+    use_public = args.public or PUBLIC
+    run_server(port=port, use_public=use_public)
+if __name__ == "__main__":
+    main()

praisonai/auto.py ADDED Viewed

@@ -0,0 +1,238 @@
+from openai import OpenAI
+from pydantic import BaseModel
+from typing import Dict, List, Optional
+import instructor
+import os
+import json
+import yaml
+from rich import print
+import logging
+# Framework-specific imports with availability checks
+CREWAI_AVAILABLE = False
+AUTOGEN_AVAILABLE = False
+PRAISONAI_TOOLS_AVAILABLE = False
+PRAISONAI_AVAILABLE = False
+try:
+    from praisonaiagents import Agent as PraisonAgent, Task as PraisonTask, PraisonAIAgents
+    PRAISONAI_AVAILABLE = True
+except ImportError:
+    pass
+try:
+    from crewai import Agent, Task, Crew
+    CREWAI_AVAILABLE = True
+except ImportError:
+    pass
+try:
+    import autogen
+    AUTOGEN_AVAILABLE = True
+except ImportError:
+    pass
+try:
+    from praisonai_tools import (
+        CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool,
+        DirectoryReadTool, FileReadTool, TXTSearchTool, JSONSearchTool,
+        MDXSearchTool, PDFSearchTool, RagTool, ScrapeElementFromWebsiteTool,
+        ScrapeWebsiteTool, WebsiteSearchTool, XMLSearchTool,
+        YoutubeChannelSearchTool, YoutubeVideoSearchTool
+    )
+    PRAISONAI_TOOLS_AVAILABLE = True
+except ImportError:
+    PRAISONAI_TOOLS_AVAILABLE = False
+logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO').upper(), format='%(asctime)s - %(levelname)s - %(message)s')
+# Define Pydantic models outside of the generate method
+class TaskDetails(BaseModel):
+    description: str
+    expected_output: str
+class RoleDetails(BaseModel):
+    role: str
+    goal: str
+    backstory: str
+    tasks: Dict[str, TaskDetails]
+    tools: List[str]
+class TeamStructure(BaseModel):
+    roles: Dict[str, RoleDetails]
+class AutoGenerator:
+    def __init__(self, topic="Movie Story writing about AI", agent_file="test.yaml", framework="crewai", config_list: Optional[List[Dict]] = None):
+        """
+        Initialize the AutoGenerator class with the specified topic, agent file, and framework.
+        Note: autogen framework is different from this AutoGenerator class.
+        """
+        # Validate framework availability and show framework-specific messages
+        if framework == "crewai" and not CREWAI_AVAILABLE:
+            raise ImportError("""
+CrewAI is not installed. Please install with:
+    pip install "praisonai[crewai]"
+""")
+        elif framework == "autogen" and not AUTOGEN_AVAILABLE:
+            raise ImportError("""
+AutoGen is not installed. Please install with:
+    pip install "praisonai[autogen]"
+""")
+        elif framework == "praisonai" and not PRAISONAI_AVAILABLE:
+            raise ImportError("""
+Praisonai is not installed. Please install with:
+    pip install praisonaiagents
+""")
+        # Only show tools message if using a framework and tools are needed
+        if (framework in ["crewai", "autogen"]) and not PRAISONAI_TOOLS_AVAILABLE:
+            logging.warning(f"""
+Tools are not available for {framework}. To use tools, install:
+    pip install "praisonai[{framework}]"
+""")
+        self.config_list = config_list or [
+            {
+                '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.topic = topic
+        self.agent_file = agent_file
+        self.framework = framework or "praisonai"
+        self.client = instructor.patch(
+            OpenAI(
+                base_url=self.config_list[0]['base_url'],
+                api_key=os.getenv("OPENAI_API_KEY"),
+            ),
+            mode=instructor.Mode.JSON,
+        )
+    def generate(self):
+        """
+        Generates a team structure for the specified topic.
+        Args:
+            None
+        Returns:
+            str: The full path of the YAML file containing the generated team structure.
+        Raises:
+            Exception: If the generation process fails.
+        Usage:
+            generator = AutoGenerator(framework="crewai", topic="Create a movie script about Cat in Mars")
+            path = generator.generate()
+            print(path)
+        """
+        response = self.client.chat.completions.create(
+            model=self.config_list[0]['model'],
+            response_model=TeamStructure,
+            max_retries=10,
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant designed to output complex team structures."},
+                {"role": "user", "content": self.get_user_content()}
+            ]
+        )
+        json_data = json.loads(response.model_dump_json())
+        self.convert_and_save(json_data)
+        full_path = os.path.abspath(self.agent_file)
+        return full_path
+    def convert_and_save(self, json_data):
+        """Converts the provided JSON data into the desired YAML format and saves it to a file.
+        Args:
+            json_data (dict): The JSON data representing the team structure.
+            topic (str, optional): The topic to be inserted into the YAML. Defaults to "Artificial Intelligence".
+            agent_file (str, optional): The name of the YAML file to save. Defaults to "test.yaml".
+        """
+        yaml_data = {
+            "framework": self.framework,
+            "topic": self.topic,
+            "roles": {},
+            "dependencies": []
+        }
+        for role_id, role_details in json_data['roles'].items():
+            yaml_data['roles'][role_id] = {
+                "backstory": "" + role_details['backstory'],
+                "goal": role_details['goal'],
+                "role": role_details['role'],
+                "tasks": {},
+                # "tools": role_details.get('tools', []),
+                "tools": ['']
+            }
+            for task_id, task_details in role_details['tasks'].items():
+                yaml_data['roles'][role_id]['tasks'][task_id] = {
+                    "description": "" + task_details['description'],
+                    "expected_output": "" + task_details['expected_output']
+                }
+        # Save to YAML file, maintaining the order
+        with open(self.agent_file, 'w') as f:
+            yaml.dump(yaml_data, f, allow_unicode=True, sort_keys=False)
+    def get_user_content(self):
+        """
+        Generates a prompt for the OpenAI API to generate a team structure.
+        Args:
+            None
+        Returns:
+            str: The prompt for the OpenAI API.
+        Usage:
+            generator = AutoGenerator(framework="crewai", topic="Create a movie script about Cat in Mars")
+            prompt = generator.get_user_content()
+            print(prompt)
+        """
+        user_content = """Generate a team structure for  \"""" + self.topic + """\" task.
+No Input data will be provided to the team.
+The team will work in sequence. First role will pass the output to the next role, and so on.
+The last role will generate the final output.
+Think step by step.
+With maximum 3 roles, each with 1 task. Include role goals, backstories, task descriptions, and expected outputs.
+List of Available Tools: CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool, DirectoryReadTool, FileReadTool, TXTSearchTool, JSONSearchTool, MDXSearchTool, PDFSearchTool, RagTool, ScrapeElementFromWebsiteTool, ScrapeWebsiteTool, WebsiteSearchTool, XMLSearchTool, YoutubeChannelSearchTool, YoutubeVideoSearchTool.
+Only use Available Tools. Do Not use any other tools.
+Example Below:
+Use below example to understand the structure of the output.
+The final role you create should satisfy the provided task: """ + self.topic + """.
+{
+"roles": {
+"narrative_designer": {
+"role": "Narrative Designer",
+"goal": "Create AI storylines",
+"backstory": "Skilled in narrative development for AI, with a focus on story resonance.",
+"tools": ["ScrapeWebsiteTool"],
+"tasks": {
+"story_concept_development": {
+"description": "Craft a unique AI story concept with depth and engagement using concept from this page the content https://www.asthebirdfliesblog.com/posts/how-to-write-book-story-development .",
+"expected_output": "Document with narrative arcs, character bios, and settings."
+}
+}
+},
+"scriptwriter": {
+"role": "Scriptwriter",
+"goal": "Write scripts from AI concepts",
+"backstory": "Expert in dialogue and script structure, translating concepts into scripts.",
+"tasks": {
+"scriptwriting_task": {
+"description": "Turn narrative concepts into scripts, including dialogue and scenes.",
+"expected_output": "Production-ready script with dialogue and scene details."
+}
+}
+}
+}
+}
+        """
+        return user_content
+# generator = AutoGenerator(framework="crewai", topic="Create a movie script about Cat in Mars")
+# print(generator.generate())