PraisonAI 1.0.6__tar.gz → 1.0.9__tar.gz

{praisonai-1.0.6 → praisonai-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PraisonAI
-Version: 1.0.6
+Version: 1.0.9
 Summary: PraisonAI application combines AutoGen and CrewAI or similar frameworks into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customization, and efficient human-agent collaboration.
 Author: Mervin Praison
 Requires-Python: >=3.10,<3.13
@@ -116,7 +116,7 @@ Praison AI, leveraging both AutoGen and CrewAI or any other agent framework, rep
 
 ## Installation Options
 
-### Basic Installation
+### Using pip
 ```bash
 pip install praisonai
 ```
@@ -435,12 +435,26 @@ if __name__ == "__main__":
    ```
 
 4. **Install only dev dependencies:**
+
    ```sh
    poetry install --with dev
    ```
 
 This configuration ensures that your development dependencies are correctly categorized and installed as needed.
 
+### Using uv (Fast Python Package Installer)
+```bash
+# Install uv if you haven't already
+pip install uv
+
+# Install from requirements
+uv pip install -r pyproject.toml
+
+# Install with extras
+uv pip install -r pyproject.toml --extra code
+uv pip install -r pyproject.toml --extra "crewai,autogen"
+```
+
 ## Contributing
 
 - Fork on GitHub: Use the "Fork" button on the repository page.
@@ -480,4 +494,3 @@ Praison AI is an open-sourced software licensed under the **[MIT license](https:
 
 Praison AI is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.
 
-

{praisonai-1.0.6 → praisonai-1.0.9}/README.md

@@ -53,7 +53,7 @@ Praison AI, leveraging both AutoGen and CrewAI or any other agent framework, rep
 
 ## Installation Options
 
-### Basic Installation
+### Using pip
 ```bash
 pip install praisonai
 ```
@@ -372,12 +372,26 @@ if __name__ == "__main__":
    ```
 
 4. **Install only dev dependencies:**
+
    ```sh
    poetry install --with dev
    ```
 
 This configuration ensures that your development dependencies are correctly categorized and installed as needed.
 
+### Using uv (Fast Python Package Installer)
+```bash
+# Install uv if you haven't already
+pip install uv
+
+# Install from requirements
+uv pip install -r pyproject.toml
+
+# Install with extras
+uv pip install -r pyproject.toml --extra code
+uv pip install -r pyproject.toml --extra "crewai,autogen"
+```
+
 ## Contributing
 
 - Fork on GitHub: Use the "Fork" button on the repository page.
@@ -416,4 +430,3 @@ Praison AI is an open-sourced software licensed under the **[MIT license](https:
 ## License
 
 Praison AI is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.
-

{praisonai-1.0.6 → praisonai-1.0.9}/praisonai/cli.py

@@ -26,9 +26,16 @@ CREWAI_AVAILABLE = False
 AUTOGEN_AVAILABLE = False
 
 try:
-    # Set CHAINLIT_APP_ROOT only if it doesn't exist
+    # Create necessary directories and set CHAINLIT_APP_ROOT
     if "CHAINLIT_APP_ROOT" not in os.environ:
-        os.environ["CHAINLIT_APP_ROOT"] = os.path.join(os.path.expanduser("~"), ".praison")
+        chainlit_root = os.path.join(os.path.expanduser("~"), ".praison")
+        os.environ["CHAINLIT_APP_ROOT"] = chainlit_root
+    else:
+        chainlit_root = os.environ["CHAINLIT_APP_ROOT"]
+        
+    os.makedirs(chainlit_root, exist_ok=True)
+    os.makedirs(os.path.join(chainlit_root, ".files"), exist_ok=True)
+    
     from chainlit.cli import chainlit_run
     CHAINLIT_AVAILABLE = True
 except ImportError:
@@ -393,15 +400,6 @@ class PraisonAI:
             root_path = os.path.join(os.path.expanduser("~"), ".praison")
             if "CHAINLIT_APP_ROOT" not in os.environ:
                 os.environ["CHAINLIT_APP_ROOT"] = root_path
-            public_folder = os.path.join(os.path.dirname(praisonai.__file__), 'public')
-            if not os.path.exists(os.path.join(root_path, "public")):
-                if os.path.exists(public_folder):
-                    shutil.copytree(public_folder, os.path.join(root_path, "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:

{praisonai-1.0.6 → praisonai-1.0.9}/praisonai/deploy.py

@@ -56,7 +56,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==1.0.6 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==1.0.9 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

{praisonai-1.0.6 → praisonai-1.0.9}/praisonai/ui/chat.py

@@ -1,29 +1,32 @@
-import chainlit as cl
-from chainlit.input_widget import TextInput
-from chainlit.types import ThreadDict
-from litellm import acompletion
+# Standard library imports
 import os
-import sqlite3
 from datetime import datetime
-from typing import Dict, List, Optional
-from dotenv import load_dotenv
-load_dotenv()
-import chainlit.data as cl_data
-from chainlit.step import StepDict
-from literalai.helper import utc_now
+from typing import Dict, Optional
 import logging
 import json
-from sql_alchemy import SQLAlchemyDataLayer
-from tavily import TavilyClient
-from crawl4ai import AsyncWebCrawler
 import asyncio
-from PIL import Image
 import io
 import base64
 
-from sqlalchemy.ext.asyncio import create_async_engine
-from sqlalchemy import text
+# Third-party imports
+from dotenv import load_dotenv
+from PIL import Image
+from tavily import TavilyClient
+from crawl4ai import AsyncWebCrawler
 
+# Local application/library imports
+import chainlit as cl
+from chainlit.input_widget import TextInput
+from chainlit.types import ThreadDict
+import chainlit.data as cl_data
+from litellm import acompletion
+from literalai.helper import utc_now
+from db import DatabaseManager
+
+# Load environment variables
+load_dotenv()
+
+# Logging configuration
 logger = logging.getLogger(__name__)
 log_level = os.getenv("LOGLEVEL", "INFO").upper()
 logger.handlers = []
@@ -42,233 +45,19 @@ if not CHAINLIT_AUTH_SECRET:
 now = utc_now()
 create_step_counter = 0
 
-DATABASE_URL = os.getenv("DATABASE_URL")
-
-async def create_schema_async():
-    if not DATABASE_URL:
-        return
-    engine = create_async_engine(DATABASE_URL, echo=False)
-    async with engine.begin() as conn:
-        # Use double quotes for column names and renamed start/end to startTime/endTime
-        await conn.execute(text('''
-            CREATE TABLE IF NOT EXISTS users (
-                "id" TEXT PRIMARY KEY,
-                "identifier" TEXT NOT NULL UNIQUE,
-                "meta" TEXT NOT NULL DEFAULT '{}',
-                "createdAt" TEXT
-            );
-        '''))
-        await conn.execute(text('''
-            CREATE TABLE IF NOT EXISTS threads (
-                "id" TEXT PRIMARY KEY,
-                "createdAt" TEXT,
-                "name" TEXT,
-                "userId" TEXT,
-                "userIdentifier" TEXT,
-                "tags" TEXT DEFAULT '[]',
-                "meta" TEXT NOT NULL DEFAULT '{}',
-                FOREIGN KEY ("userId") REFERENCES users("id") ON DELETE CASCADE
-            );
-        '''))
-        await conn.execute(text('''
-            CREATE TABLE IF NOT EXISTS steps (
-                "id" TEXT PRIMARY KEY,
-                "name" TEXT NOT NULL,
-                "type" TEXT NOT NULL,
-                "threadId" TEXT NOT NULL,
-                "parentId" TEXT,
-                "disableFeedback" BOOLEAN NOT NULL DEFAULT FALSE,
-                "streaming" BOOLEAN NOT NULL DEFAULT FALSE,
-                "waitForAnswer" BOOLEAN DEFAULT FALSE,
-                "isError" BOOLEAN NOT NULL DEFAULT FALSE,
-                "meta" TEXT DEFAULT '{}',
-                "tags" TEXT DEFAULT '[]',
-                "input" TEXT,
-                "output" TEXT,
-                "createdAt" TEXT,
-                "startTime" TEXT,
-                "endTime" TEXT,
-                "generation" TEXT,
-                "showInput" TEXT,
-                "language" TEXT,
-                "indent" INT,
-                FOREIGN KEY ("threadId") REFERENCES threads("id") ON DELETE CASCADE
-            );
-        '''))
-        await conn.execute(text('''
-            CREATE TABLE IF NOT EXISTS elements (
-                "id" TEXT PRIMARY KEY,
-                "threadId" TEXT,
-                "type" TEXT,
-                "url" TEXT,
-                "chainlitKey" TEXT,
-                "name" TEXT NOT NULL,
-                "display" TEXT,
-                "objectKey" TEXT,
-                "size" TEXT,
-                "page" INT,
-                "language" TEXT,
-                "forId" TEXT,
-                "mime" TEXT,
-                FOREIGN KEY ("threadId") REFERENCES threads("id") ON DELETE CASCADE
-            );
-        '''))
-        await conn.execute(text('''
-            CREATE TABLE IF NOT EXISTS feedbacks (
-                "id" TEXT PRIMARY KEY,
-                "forId" TEXT NOT NULL,
-                "value" INT NOT NULL,
-                "threadId" TEXT,
-                "comment" TEXT
-            );
-        '''))
-        await conn.execute(text('''
-            CREATE TABLE IF NOT EXISTS settings (
-                "id" SERIAL PRIMARY KEY,
-                "key" TEXT UNIQUE,
-                "value" TEXT
-            );
-        '''))
-    await engine.dispose()
-
-def create_schema_sqlite(db_path: str):
-    os.makedirs(os.path.dirname(db_path), exist_ok=True)
-    conn = sqlite3.connect(db_path)
-    cursor = conn.cursor()
-    # Renamed start to startTime, end to endTime
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS users (
-            "id" TEXT PRIMARY KEY,
-            "identifier" TEXT NOT NULL UNIQUE,
-            "meta" TEXT NOT NULL DEFAULT '{}',
-            "createdAt" TEXT
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS threads (
-            "id" TEXT PRIMARY KEY,
-            "createdAt" TEXT,
-            "name" TEXT,
-            "userId" TEXT,
-            "userIdentifier" TEXT,
-            "tags" TEXT DEFAULT '[]',
-            "meta" TEXT NOT NULL DEFAULT '{}',
-            FOREIGN KEY ("userId") REFERENCES users("id") ON DELETE CASCADE
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS steps (
-            "id" TEXT PRIMARY KEY,
-            "name" TEXT NOT NULL,
-            "type" TEXT NOT NULL,
-            "threadId" TEXT NOT NULL,
-            "parentId" TEXT,
-            "disableFeedback" BOOLEAN NOT NULL DEFAULT 0,
-            "streaming" BOOLEAN NOT NULL DEFAULT 0,
-            "waitForAnswer" BOOLEAN DEFAULT 0,
-            "isError" BOOLEAN NOT NULL DEFAULT 0,
-            "meta" TEXT DEFAULT '{}',
-            "tags" TEXT DEFAULT '[]',
-            "input" TEXT,
-            "output" TEXT,
-            "createdAt" TEXT,
-            "startTime" TEXT,
-            "endTime" TEXT,
-            "generation" TEXT,
-            "showInput" TEXT,
-            "language" TEXT,
-            "indent" INT,
-            FOREIGN KEY ("threadId") REFERENCES threads ("id") ON DELETE CASCADE
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS elements (
-            "id" TEXT PRIMARY KEY,
-            "threadId" TEXT,
-            "type" TEXT,
-            "url" TEXT,
-            "chainlitKey" TEXT,
-            "name" TEXT NOT NULL,
-            "display" TEXT,
-            "objectKey" TEXT,
-            "size" TEXT,
-            "page" INT,
-            "language" TEXT,
-            "forId" TEXT,
-            "mime" TEXT,
-            FOREIGN KEY ("threadId") REFERENCES threads ("id") ON DELETE CASCADE
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS feedbacks (
-            "id" TEXT PRIMARY KEY,
-            "forId" TEXT NOT NULL,
-            "value" INT NOT NULL,
-            "threadId" TEXT,
-            "comment" TEXT
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS settings (
-            "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-            "key" TEXT UNIQUE,
-            "value" TEXT
-        )
-    ''')
-    conn.commit()
-    conn.close()
-
-if DATABASE_URL:
-    asyncio.run(create_schema_async())
-    conninfo = DATABASE_URL
-else:
-    DB_PATH = os.path.expanduser("~/.praison/database.sqlite")
-    create_schema_sqlite(DB_PATH)
-    conninfo = f"sqlite+aiosqlite:///{DB_PATH}"
+# Initialize database
+db_manager = DatabaseManager()
+db_manager.initialize()
 
 def save_setting(key: str, value: str):
-    if DATABASE_URL:
-        async def save_setting_async():
-            engine = create_async_engine(DATABASE_URL, echo=False)
-            async with engine.begin() as conn:
-                await conn.execute(text("""
-                    INSERT INTO settings ("key", "value") VALUES (:key, :value)
-                    ON CONFLICT ("key") DO UPDATE SET "value" = EXCLUDED."value"
-                """), {"key": key, "value": value})
-            await engine.dispose()
-        asyncio.run(save_setting_async())
-    else:
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        cursor.execute(
-            """
-            INSERT OR REPLACE INTO settings (id, "key", "value")
-            VALUES ((SELECT id FROM settings WHERE "key" = ?), ?, ?)
-            """,
-            (key, key, value),
-        )
-        conn.commit()
-        conn.close()
+    """Save a setting to the database"""
+    asyncio.run(db_manager.save_setting(key, value))
 
 def load_setting(key: str) -> str:
-    if DATABASE_URL:
-        async def load_setting_async():
-            engine = create_async_engine(DATABASE_URL, echo=False)
-            async with engine.connect() as conn:
-                result = await conn.execute(text('SELECT "value" FROM settings WHERE "key" = :key'), {"key": key})
-                row = result.fetchone()
-            await engine.dispose()
-            return row[0] if row else None
-        return asyncio.run(load_setting_async())
-    else:
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        cursor.execute('SELECT "value" FROM settings WHERE "key" = ?', (key,))
-        result = cursor.fetchone()
-        conn.close()
-        return result[0] if result else None
+    """Load a setting from the database"""
+    return asyncio.run(db_manager.load_setting(key))
 
-cl_data._data_layer = SQLAlchemyDataLayer(conninfo=conninfo)
+cl_data._data_layer = db_manager
 
 tavily_api_key = os.getenv("TAVILY_API_KEY")
 tavily_client = TavilyClient(api_key=tavily_api_key) if tavily_api_key else None
@@ -389,7 +178,7 @@ async def setup_agent(settings):
             if isinstance(metadata, str):
                 try:
                     metadata = json.loads(metadata)
-                except:
+                except json.JSONDecodeError:
                     metadata = {}
             metadata["model_name"] = model_name
             await cl_data.update_thread(thread_id, metadata=metadata)

{praisonai-1.0.6 → praisonai-1.0.9}/praisonai/ui/code.py

@@ -1,23 +1,29 @@
-import chainlit as cl
-from chainlit.input_widget import TextInput
-from chainlit.types import ThreadDict, StepDict
+# Standard library imports
 import os
-import sqlite3
 from datetime import datetime
-from typing import Dict, List, Optional
-from dotenv import load_dotenv
-load_dotenv()
-import chainlit.data as cl_data
 import logging
 import json
-from sql_alchemy import SQLAlchemyDataLayer
+import io
+import base64
+import asyncio
+
+# Third-party imports
+from dotenv import load_dotenv
+from PIL import Image
 from context import ContextGatherer
 from tavily import TavilyClient
-from datetime import datetime
 from crawl4ai import AsyncWebCrawler
-from PIL import Image
-import io
-import base64
+
+# Local application/library imports
+import chainlit as cl
+from chainlit.input_widget import TextInput
+from chainlit.types import ThreadDict
+import chainlit.data as cl_data
+from litellm import acompletion
+from db import DatabaseManager
+
+# Load environment variables
+load_dotenv()
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -41,143 +47,38 @@ if not CHAINLIT_AUTH_SECRET:
     CHAINLIT_AUTH_SECRET = os.getenv("CHAINLIT_AUTH_SECRET")
 
 now = datetime.now()
-
 create_step_counter = 0
 
-DB_PATH = os.path.expanduser("~/.praison/database.sqlite")
-
-def initialize_db():
-    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS users (
-            id UUID PRIMARY KEY,
-            identifier TEXT NOT NULL UNIQUE,
-            metadata JSONB NOT NULL,
-            createdAt TEXT
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS threads (
-            id UUID PRIMARY KEY,
-            createdAt TEXT,
-            name TEXT,
-            userId UUID,
-            userIdentifier TEXT,
-            tags TEXT[],
-            metadata JSONB NOT NULL DEFAULT '{}',
-            FOREIGN KEY (userId) REFERENCES users(id) ON DELETE CASCADE
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS steps (
-            id UUID PRIMARY KEY,
-            name TEXT NOT NULL,
-            type TEXT NOT NULL,
-            threadId UUID NOT NULL,
-            parentId UUID,
-            disableFeedback BOOLEAN NOT NULL DEFAULT 0,
-            streaming BOOLEAN NOT NULL DEFAULT 0,
-            waitForAnswer BOOLEAN DEFAULT 0,
-            isError BOOLEAN NOT NULL DEFAULT 0,
-            metadata JSONB DEFAULT '{}',
-            tags TEXT[],
-            input TEXT,
-            output TEXT,
-            createdAt TEXT,
-            start TEXT,
-            end TEXT,
-            generation JSONB,
-            showInput TEXT,
-            language TEXT,
-            indent INT,
-            FOREIGN KEY (threadId) REFERENCES threads (id) ON DELETE CASCADE
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS elements (
-            id UUID PRIMARY KEY,
-            threadId UUID,
-            type TEXT,
-            url TEXT,
-            chainlitKey TEXT,
-            name TEXT NOT NULL,
-            display TEXT,
-            objectKey TEXT,
-            size TEXT,
-            page INT,
-            language TEXT,
-            forId UUID,
-            mime TEXT,
-            FOREIGN KEY (threadId) REFERENCES threads (id) ON DELETE CASCADE
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS feedbacks (
-            id UUID PRIMARY KEY,
-            forId UUID NOT NULL,
-            value INT NOT NULL,
-            threadId UUID,
-            comment TEXT
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS settings (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            key TEXT UNIQUE,
-            value TEXT
-        )
-    ''')
-    conn.commit()
-    conn.close()
+# Initialize database
+db_manager = DatabaseManager()
+db_manager.initialize()
+
+deleted_thread_ids = []  # type: List[str]
 
 def save_setting(key: str, value: str):
     """Saves a setting to the database.
-
+    
     Args:
         key: The setting key.
         value: The setting value.
     """
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute(
-        """
-        INSERT OR REPLACE INTO settings (id, key, value)
-        VALUES ((SELECT id FROM settings WHERE key = ?), ?, ?)
-    """,
-        (key, key, value),
-    )
-    conn.commit()
-    conn.close()
+    asyncio.run(db_manager.save_setting(key, value))
 
 def load_setting(key: str) -> str:
     """Loads a setting from the database.
-
+    
     Args:
         key: The setting key.
-
+    
     Returns:
         The setting value, or None if the key is not found.
     """
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute('SELECT value FROM settings WHERE key = ?', (key,))
-    result = cursor.fetchone()
-    conn.close()
-    return result[0] if result else None
-
-
-# Initialize the database
-initialize_db()
-
-deleted_thread_ids = []  # type: List[str]
+    return asyncio.run(db_manager.load_setting(key))
 
-cl_data._data_layer = SQLAlchemyDataLayer(conninfo=f"sqlite+aiosqlite:///{DB_PATH}")
+cl_data._data_layer = db_manager
 
 @cl.on_chat_start
 async def start():
-    initialize_db()
     model_name = load_setting("model_name") 
 
     if (model_name):
@@ -498,7 +399,6 @@ async def on_chat_resume(thread: ThreadDict):
         ]
     )
     await settings.send()
-    thread_id = thread["id"]
     cl.user_session.set("thread_id", thread["id"])
     
     # Ensure metadata is a dictionary