PraisonAI 1.0.5__tar.gz → 1.0.8__tar.gz

{praisonai-1.0.5 → praisonai-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PraisonAI
-Version: 1.0.5
+Version: 1.0.8
 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,11 +116,24 @@ Praison AI, leveraging both AutoGen and CrewAI or any other agent framework, rep
 
 ## Installation Options
 
-### Basic Installation
+### Using pip
 ```bash
 pip install praisonai
 ```
 
+### 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"
+```
+
 ### Framework-specific Installation
 ```bash
 # Install with CrewAI support
@@ -435,6 +448,7 @@ if __name__ == "__main__":
    ```
 
 4. **Install only dev dependencies:**
+
    ```sh
    poetry install --with dev
    ```
@@ -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.5 → praisonai-1.0.8}/README.md

@@ -53,11 +53,24 @@ Praison AI, leveraging both AutoGen and CrewAI or any other agent framework, rep
 
 ## Installation Options
 
-### Basic Installation
+### Using pip
 ```bash
 pip install praisonai
 ```
 
+### 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"
+```
+
 ### Framework-specific Installation
 ```bash
 # Install with CrewAI support
@@ -372,6 +385,7 @@ if __name__ == "__main__":
    ```
 
 4. **Install only dev dependencies:**
+
    ```sh
    poetry install --with dev
    ```
@@ -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.5 → praisonai-1.0.8}/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.5 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==1.0.8 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

{praisonai-1.0.5 → praisonai-1.0.8}/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
@@ -323,6 +112,37 @@ tools = [{
     }
 }] if tavily_api_key else []
 
+# Authentication configuration
+AUTH_PASSWORD_ENABLED = os.getenv("AUTH_PASSWORD_ENABLED", "true").lower() == "true"  # Password authentication enabled by default
+AUTH_OAUTH_ENABLED = os.getenv("AUTH_OAUTH_ENABLED", "false").lower() == "true"    # OAuth authentication disabled by default
+
+username = os.getenv("CHAINLIT_USERNAME", "admin")
+password = os.getenv("CHAINLIT_PASSWORD", "admin")
+
+def auth_callback(u: str, p: str):
+    if (u, p) == (username, password):
+        return cl.User(identifier=username, metadata={"role": "ADMIN", "provider": "credentials"})
+    return None
+
+def oauth_callback(
+    provider_id: str,
+    token: str,
+    raw_user_data: Dict[str, str],
+    default_user: cl.User,
+) -> Optional[cl.User]:
+    return default_user
+
+if AUTH_PASSWORD_ENABLED:
+    auth_callback = cl.password_auth_callback(auth_callback)
+
+if AUTH_OAUTH_ENABLED:
+    oauth_callback = cl.oauth_callback(oauth_callback)
+
+async def send_count():
+    await cl.Message(
+        f"Create step counter: {create_step_counter}", disable_feedback=True
+    ).send()
+
 @cl.on_chat_start
 async def start():
     model_name = load_setting("model_name") or os.getenv("MODEL_NAME", "gpt-4o-mini")
@@ -358,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)
@@ -516,23 +336,6 @@ User Question: {message.content}
         msg.content = full_response
         await msg.update()
 
-username = os.getenv("CHAINLIT_USERNAME", "admin")
-password = os.getenv("CHAINLIT_PASSWORD", "admin")
-
-@cl.password_auth_callback
-def auth_callback(u: str, p: str):
-    if (u, p) == (username, password):
-        return cl.User(
-            identifier=username, metadata={"role": "ADMIN", "provider": "credentials"}
-        )
-    else:
-        return None
-
-async def send_count():
-    await cl.Message(
-        f"Create step counter: {create_step_counter}", disable_feedback=True
-    ).send()
-
 @cl.on_chat_resume
 async def on_chat_resume(thread: ThreadDict):
     logger.info(f"Resuming chat: {thread['id']}")

{praisonai-1.0.5 → praisonai-1.0.8}/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

praisonai-1.0.8/praisonai/ui/db.py

@@ -0,0 +1,242 @@
+import os
+import sqlite3
+import asyncio
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+from sql_alchemy import SQLAlchemyDataLayer
+import chainlit.data as cl_data
+from chainlit.types import ThreadDict
+
+class DatabaseManager(SQLAlchemyDataLayer):
+    def __init__(self):
+        self.database_url = os.getenv("DATABASE_URL")
+        supabase_url = os.getenv("SUPABASE_DATABASE_URL")
+        if supabase_url:
+            self.database_url = supabase_url
+        
+        if self.database_url:
+            self.conninfo = self.database_url
+        else:
+            self.db_path = os.path.expanduser("~/.praison/database.sqlite")
+            os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+            self.conninfo = f"sqlite+aiosqlite:///{self.db_path}"
+        
+        # Initialize SQLAlchemyDataLayer with the connection info
+        super().__init__(conninfo=self.conninfo)
+
+    async def create_schema_async(self):
+        """Create the database schema for PostgreSQL"""
+        if not self.database_url:
+            return
+        engine = create_async_engine(self.database_url, echo=False)
+        async with engine.begin() as conn:
+            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(self):
+        """Create the database schema for SQLite"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        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()
+
+    def initialize(self):
+        """Initialize the database with schema based on the configuration"""
+        if self.database_url:
+            asyncio.run(self.create_schema_async())
+        else:
+            self.create_schema_sqlite()
+
+    async def save_setting(self, key: str, value: str):
+        """Save a setting to the database"""
+        if self.database_url:
+            async with self.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})
+        else:
+            conn = sqlite3.connect(self.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()
+
+    async def load_setting(self, key: str) -> str:
+        """Load a setting from the database"""
+        if self.database_url:
+            async with self.engine.connect() as conn:
+                result = await conn.execute(text('SELECT "value" FROM settings WHERE "key" = :key'), {"key": key})
+                row = result.fetchone()
+                return row[0] if row else None
+        else:
+            conn = sqlite3.connect(self.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

{praisonai-1.0.5 → praisonai-1.0.8}/praisonai/ui/sql_alchemy.py

@@ -34,6 +34,10 @@ if TYPE_CHECKING:
     from chainlit.step import StepDict
 
 DATABASE_URL = os.getenv("DATABASE_URL")
+SUPABASE_DATABASE_URL = os.getenv("SUPABASE_DATABASE_URL")
+if SUPABASE_DATABASE_URL:
+    # If a Supabase database URL is provided, use it.
+    DATABASE_URL = SUPABASE_DATABASE_URL
 
 class SQLAlchemyDataLayer(BaseDataLayer):
     def __init__(
@@ -262,7 +266,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
             )
         if not filters.userId:
             raise ValueError("userId is required")
-        all_user_threads: List[ThreadDict] = (
+        all_user_threads: Optional[List[ThreadDict]] = (
             await self.get_all_user_threads(user_id=filters.userId) or []
         )
 
@@ -324,8 +328,6 @@ class SQLAlchemyDataLayer(BaseDataLayer):
             else None
         )
 
-        # Use updated column names: startTime, endTime
-        # Make sure tags is always a JSON array
         tags = step_dict.get("tags")
         if not tags:
             tags = []

{praisonai-1.0.5 → praisonai-1.0.8}/pyproject.toml

@@ -1,6 +1,16 @@
+[project]
+name = "PraisonAI"
+version = "1.0.8"
+description = "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."
+readme = "README.md"
+license = ""
+authors = [
+    { name = "Mervin Praison" }
+]
+
 [tool.poetry]
 name = "PraisonAI"
-version = "1.0.5"
+version = "1.0.8"
 description = "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."
 authors = ["Mervin Praison"]
 license = ""