PraisonAI 1.0.2__cp312-cp312-manylinux_2_35_x86_64.whl → 1.0.4__cp312-cp312-manylinux_2_35_x86_64.whl

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.2 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==1.0.4 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

praisonai/ui/chat.py

@@ -1,6 +1,6 @@
 import chainlit as cl
 from chainlit.input_widget import TextInput
-from chainlit.types import ThreadDict  # Change this import
+from chainlit.types import ThreadDict  
 from litellm import acompletion
 import os
 import sqlite3
@@ -9,7 +9,6 @@ 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
 import logging
 import json
@@ -20,6 +19,8 @@ import asyncio
 from PIL import Image
 import io
 import base64
+from sqlalchemy import text
+from sqlalchemy.exc import DatabaseError
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -48,140 +49,221 @@ 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()
-
-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()
-
-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
-
+async def create_tables(engine):
+    """Create all necessary tables if they don't exist."""
+    try:
+        async with engine.begin() as conn:
+            # Check if we're using PostgreSQL
+            dialect = engine.dialect.name
+            if dialect == 'postgresql':
+                # Create tables with PostgreSQL-specific types
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS users (
+                        id UUID PRIMARY KEY,
+                        identifier TEXT NOT NULL UNIQUE,
+                        metadata JSONB NOT NULL,
+                        created_at TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS threads (
+                        id UUID PRIMARY KEY,
+                        created_at TEXT,
+                        name TEXT,
+                        user_id UUID REFERENCES users(id) ON DELETE CASCADE,
+                        user_identifier TEXT,
+                        tags TEXT[],
+                        metadata JSONB NOT NULL DEFAULT '{}'
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS steps (
+                        id UUID PRIMARY KEY,
+                        name TEXT NOT NULL,
+                        type TEXT NOT NULL,
+                        thread_id UUID NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+                        parent_id UUID,
+                        disable_feedback BOOLEAN NOT NULL DEFAULT false,
+                        streaming BOOLEAN NOT NULL DEFAULT false,
+                        wait_for_answer BOOLEAN DEFAULT false,
+                        is_error BOOLEAN NOT NULL DEFAULT false,
+                        metadata JSONB DEFAULT '{}',
+                        tags TEXT[],
+                        input TEXT,
+                        output TEXT,
+                        created_at TEXT,
+                        start_time TEXT,
+                        end_time TEXT,
+                        generation JSONB,
+                        show_input TEXT,
+                        language TEXT,
+                        indent INTEGER
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS elements (
+                        id UUID PRIMARY KEY,
+                        thread_id UUID REFERENCES threads(id) ON DELETE CASCADE,
+                        type TEXT,
+                        url TEXT,
+                        chainlit_key TEXT,
+                        name TEXT NOT NULL,
+                        display TEXT,
+                        object_key TEXT,
+                        size TEXT,
+                        page INTEGER,
+                        language TEXT,
+                        for_id UUID,
+                        mime TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS feedbacks (
+                        id UUID PRIMARY KEY,
+                        for_id UUID NOT NULL,
+                        value INTEGER NOT NULL,
+                        thread_id UUID,
+                        comment TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS settings (
+                        id SERIAL PRIMARY KEY,
+                        key TEXT UNIQUE,
+                        value TEXT
+                    )
+                """))
+                
+                # Create indexes
+                await conn.execute(text(
+                    "CREATE INDEX IF NOT EXISTS idx_steps_thread_id ON steps(thread_id)"
+                ))
+                await conn.execute(text(
+                    "CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at DESC)"
+                ))
+            else:
+                # SQLite tables (existing schema)
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS users (
+                        id TEXT PRIMARY KEY,
+                        identifier TEXT NOT NULL UNIQUE,
+                        metadata TEXT NOT NULL,
+                        created_at TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS threads (
+                        id TEXT PRIMARY KEY,
+                        created_at TEXT,
+                        name TEXT,
+                        user_id TEXT REFERENCES users(id) ON DELETE CASCADE,
+                        user_identifier TEXT,
+                        tags TEXT,
+                        metadata TEXT NOT NULL DEFAULT '{}'
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS steps (
+                        id TEXT PRIMARY KEY,
+                        name TEXT NOT NULL,
+                        type TEXT NOT NULL,
+                        thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+                        parent_id TEXT,
+                        disable_feedback INTEGER NOT NULL DEFAULT 0,
+                        streaming INTEGER NOT NULL DEFAULT 0,
+                        wait_for_answer INTEGER DEFAULT 0,
+                        is_error INTEGER NOT NULL DEFAULT 0,
+                        metadata TEXT DEFAULT '{}',
+                        tags TEXT,
+                        input TEXT,
+                        output TEXT,
+                        created_at TEXT,
+                        start_time TEXT,
+                        end_time TEXT,
+                        generation TEXT,
+                        show_input TEXT,
+                        language TEXT,
+                        indent INTEGER
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS elements (
+                        id TEXT PRIMARY KEY,
+                        thread_id TEXT REFERENCES threads(id) ON DELETE CASCADE,
+                        type TEXT,
+                        url TEXT,
+                        chainlit_key TEXT,
+                        name TEXT NOT NULL,
+                        display TEXT,
+                        object_key TEXT,
+                        size TEXT,
+                        page INTEGER,
+                        language TEXT,
+                        for_id TEXT,
+                        mime TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS feedbacks (
+                        id TEXT PRIMARY KEY,
+                        for_id TEXT NOT NULL,
+                        value INTEGER NOT NULL,
+                        thread_id TEXT,
+                        comment TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS settings (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        key TEXT UNIQUE,
+                        value TEXT
+                    )
+                """))
+                
+                # Create indexes
+                await conn.execute(text(
+                    "CREATE INDEX IF NOT EXISTS idx_steps_thread_id ON steps(thread_id)"
+                ))
+                await conn.execute(text(
+                    "CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at DESC)"
+                ))
+        
+        logger.info(f"Successfully created tables for {dialect} database")
+    except Exception as e:
+        logger.error(f"Error creating tables: {str(e)}")
+        from sqlalchemy.exc import DatabaseError as SQLAlchemyDatabaseError
+        raise SQLAlchemyDatabaseError(statement=str(e), params=None, orig=e)
 
 # Initialize the database
-initialize_db()
-
-deleted_thread_ids = []  # type: List[str]
+async def initialize_db():
+    await create_tables(cl_data._data_layer.engine)
 
 # Get database connection string from environment variable or use SQLite as default
 DB_URL = os.getenv("DATABASE_URL", f"sqlite+aiosqlite:///{DB_PATH}")
+if DB_URL.startswith('postgresql'):
+    # Convert postgresql:// to postgresql+psycopg:// if needed
+    DB_URL = DB_URL.replace('postgresql://', 'postgresql+psycopg://')
+
+# Initialize SQLAlchemy data layer
 cl_data._data_layer = SQLAlchemyDataLayer(
     conninfo=DB_URL,
     ssl_require=bool(os.getenv("DATABASE_SSL", False))
 )
 
+# Create tables if using PostgreSQL
+if DB_URL.startswith('postgresql'):
+    asyncio.run(initialize_db())
+
 # Set Tavily API key
 tavily_api_key = os.getenv("TAVILY_API_KEY")
 tavily_client = TavilyClient(api_key=tavily_api_key) if tavily_api_key else None
@@ -241,10 +323,53 @@ tools = [{
     }
 }] if tavily_api_key else []
 
+async def save_setting(key: str, value: str):
+    """Saves a setting to the database.
+
+    Args:
+        key: The setting key.
+        value: The setting value.
+    """
+    try:
+        async with cl_data._data_layer.engine.begin() as conn:
+            await conn.execute(
+                text("""
+                INSERT INTO settings (key, value)
+                VALUES (:key, :value)
+                ON CONFLICT (key) DO UPDATE SET value = :value
+                """),
+                {"key": key, "value": value}
+            )
+        logger.debug(f"Saved setting {key}={value}")
+    except Exception as e:
+        logger.error(f"Error saving setting {key}: {str(e)}")
+        raise DatabaseError(f"Failed to save setting: {str(e)}")
+
+async 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.
+    """
+    try:
+        async with cl_data._data_layer.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
+    except Exception as e:
+        logger.error(f"Error loading setting {key}: {str(e)}")
+        return None
+
 @cl.on_chat_start
 async def start():
-    initialize_db()
-    model_name = load_setting("model_name") 
+    await initialize_db()
+    model_name = await load_setting("model_name") 
 
     if model_name:
         cl.user_session.set("model_name", model_name)
@@ -274,7 +399,7 @@ async def setup_agent(settings):
     cl.user_session.set("model_name", model_name)
     
     # Save in settings table
-    save_setting("model_name", model_name)
+    await save_setting("model_name", model_name)
     
     # Save in thread metadata
     thread_id = cl.user_session.get("thread_id")
@@ -292,7 +417,7 @@ async def setup_agent(settings):
 
 @cl.on_message
 async def main(message: cl.Message):
-    model_name = load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini"
+    model_name = await load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini"
     message_history = cl.user_session.get("message_history", [])
     now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     
@@ -474,7 +599,7 @@ async def send_count():
 @cl.on_chat_resume
 async def on_chat_resume(thread: ThreadDict):
     logger.info(f"Resuming chat: {thread['id']}")
-    model_name = load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini"
+    model_name = await load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini"
     logger.debug(f"Model name: {model_name}")
     settings = cl.ChatSettings(
         [

praisonai/ui/code.py

@@ -1,7 +1,6 @@
 import chainlit as cl
 from chainlit.input_widget import TextInput
-from chainlit.types import ThreadDict
-from litellm import acompletion, completion
+from chainlit.types import ThreadDict, StepDict
 import os
 import sqlite3
 from datetime import datetime
@@ -9,8 +8,6 @@ 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
 import logging
 import json
 from sql_alchemy import SQLAlchemyDataLayer
@@ -43,7 +40,7 @@ if not CHAINLIT_AUTH_SECRET:
     os.environ["CHAINLIT_AUTH_SECRET"] = "p8BPhQChpg@J>jBz$wGxqLX2V>yTVgP*7Ky9H$aV:axW~ANNX-7_T:o@lnyCBu^U"
     CHAINLIT_AUTH_SECRET = os.getenv("CHAINLIT_AUTH_SECRET")
 
-now = utc_now()
+now = datetime.now()
 
 create_step_counter = 0
 

praisonai/ui/sql_alchemy.py

@@ -12,6 +12,7 @@ from chainlit.data.base import BaseDataLayer, BaseStorageClient
 from chainlit.data.utils import queue_until_user_message
 from chainlit.element import ElementDict
 from chainlit.logger import logger
+from chainlit.message import Message
 from chainlit.step import StepDict
 from chainlit.types import (
     Feedback,
@@ -204,9 +205,10 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     async def get_thread(self, thread_id: str) -> Optional[ThreadDict]:
         if self.show_logger:
             logger.info(f"SQLAlchemy: get_thread, thread_id={thread_id}")
-        user_threads: Optional[List[ThreadDict]] = await self.get_all_user_threads(
-            thread_id=thread_id
+        user_threads: Optional[List[ThreadDict]] = (
+            await self.get_all_user_threads(thread_id=thread_id) or []
         )
+
         if user_threads:
             return user_threads[0]
         else:
@@ -335,7 +337,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### Steps ######
     @queue_until_user_message()
-    async def create_step(self, step_dict: "StepDict"):
+    async def create_step(self, step_dict: dict):
         if self.show_logger:
             logger.info(f"SQLAlchemy: create_step, step_id={step_dict.get('id')}")
 
@@ -365,7 +367,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         await self.execute_sql(query=query, parameters=parameters)
 
     @queue_until_user_message()
-    async def update_step(self, step_dict: "StepDict"):
+    async def update_step(self, step_dict: dict):
         if self.show_logger:
             logger.info(f"SQLAlchemy: update_step, step_id={step_dict.get('id')}")
         await self.create_step(step_dict)
@@ -646,37 +648,37 @@ class SQLAlchemyDataLayer(BaseDataLayer):
                             value=step_feedback["feedback_value"],
                             comment=step_feedback.get("feedback_comment"),
                         )
-                    step_dict = StepDict(
-                        id=step_feedback["step_id"],
-                        name=step_feedback["step_name"],
-                        type=step_feedback["step_type"],
-                        threadId=thread_id,
-                        parentId=step_feedback.get("step_parentid"),
-                        streaming=step_feedback.get("step_streaming", False),
-                        waitForAnswer=step_feedback.get("step_waitforanswer"),
-                        isError=step_feedback.get("step_iserror"),
-                        metadata=(
+                    step_dict = {
+                        "id": step_feedback["step_id"],
+                        "name": step_feedback["step_name"],
+                        "type": step_feedback["step_type"],
+                        "threadId": thread_id,
+                        "parentId": step_feedback.get("step_parentid"),
+                        "streaming": step_feedback.get("step_streaming", False),
+                        "waitForAnswer": step_feedback.get("step_waitforanswer"),
+                        "isError": step_feedback.get("step_iserror"),
+                        "metadata": (
                             step_feedback["step_metadata"]
                             if step_feedback.get("step_metadata") is not None
                             else {}
                         ),
-                        tags=step_feedback.get("step_tags"),
-                        input=(
+                        "tags": step_feedback.get("step_tags"),
+                        "input": (
                             step_feedback.get("step_input", "")
                             if step_feedback.get("step_showinput")
                             not in [None, "false"]
                             else ""
                         ),
-                        output=step_feedback.get("step_output", ""),
-                        createdAt=step_feedback.get("step_createdat"),
-                        start=step_feedback.get("step_start"),
-                        end=step_feedback.get("step_end"),
-                        generation=step_feedback.get("step_generation"),
-                        showInput=step_feedback.get("step_showinput"),
-                        language=step_feedback.get("step_language"),
-                        indent=step_feedback.get("step_indent"),
-                        feedback=feedback,
-                    )
+                        "output": step_feedback.get("step_output", ""),
+                        "createdAt": step_feedback.get("step_createdat"),
+                        "start": step_feedback.get("step_start"),
+                        "end": step_feedback.get("step_end"),
+                        "generation": step_feedback.get("step_generation"),
+                        "showInput": step_feedback.get("step_showinput"),
+                        "language": step_feedback.get("step_language"),
+                        "indent": step_feedback.get("step_indent"),
+                        "feedback": feedback,
+                    }
                     # Append the step to the steps list of the corresponding ThreadDict
                     thread_dicts[thread_id]["steps"].append(step_dict)
 

{praisonai-1.0.2.dist-info → praisonai-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PraisonAI
-Version: 1.0.2
+Version: 1.0.4
 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

{praisonai-1.0.2.dist-info → praisonai-1.0.4.dist-info}/RECORD

@@ -5,7 +5,7 @@ praisonai/api/call.py,sha256=iHdAlgIH_oTsEbjaGGu1Jjo6DTfMR-SfFdtSxnOLCeY,11032
 praisonai/auto.py,sha256=NDQiTV8ex_NE5C6AoY26-gMyLZNYrfthgQ6G0Dn1uhU,8304
 praisonai/chainlit_ui.py,sha256=bNR7s509lp0I9JlJNvwCZRUZosC64qdvlFCt8NmFamQ,12216
 praisonai/cli.py,sha256=Rg6vikTv4LHR1R6BIEzcaBWFvkdRZr0nOkMi6RCPKh8,21224
-praisonai/deploy.py,sha256=D7HQYTHR__UpEmBVqGf-oM-LLWMJri5gQiuNWVmngiw,6027
+praisonai/deploy.py,sha256=pxDKqvLhkqdAiUaf9Kgse3YhBfbqeEJzVOQV3XJjfZg,6027
 praisonai/inbuilt_tools/__init__.py,sha256=fai4ZJIKz7-iOnGZv5jJX0wmT77PKa4x2jqyaJddKFA,569
 praisonai/inbuilt_tools/autogen_tools.py,sha256=kJdEv61BTYvdHOaURNEpBcWq8Rs-oC03loNFTIjT-ak,4687
 praisonai/inc/__init__.py,sha256=sPDlYBBwdk0VlWzaaM_lG0_LD07lS2HRGvPdxXJFiYg,62
@@ -32,8 +32,8 @@ praisonai/setup/setup_conda_env.sh,sha256=te7s0KHsTi7XM-vkNvE0dKC1HeU2tXxqE-sPUS
 praisonai/setup.py,sha256=0jHgKnIPCtBZiGYaYyTz3PzrJI6nBy55VXk2UctXlDo,373
 praisonai/test.py,sha256=OL-wesjA5JTohr8rtr6kWoaS4ImkJg2l0GXJ-dUUfRU,4090
 praisonai/train.py,sha256=DvORlrwKOD-2v4r_z84eV3LsfzpNs-WnPKb5cQB3_t4,11071
-praisonai/ui/chat.py,sha256=rpyyFP9aICzpVEvRaKGv5EIQbpEDQZG4lvOBQ5HEJ8Y,18080
-praisonai/ui/code.py,sha256=RazArxgCQHpLJXegbgytSmcUZZi18wJRWljDjJuDbTQ,18900
+praisonai/ui/chat.py,sha256=xLiYr79CiThzudaSvwYeHxIp3qnIHN02z-lJJxCBKP4,24527
+praisonai/ui/code.py,sha256=YP100uHF6BpMyzVh_lgv32GUFLkMu88LXyoSIzv06Wg,18799
 praisonai/ui/context.py,sha256=oWO2I_WBZb7kZnuXItf18EJX0ZQv-1nAd8rxhwhuuDU,11871
 praisonai/ui/public/fantasy.svg,sha256=4Gs3kIOux-pjGtw6ogI_rv5_viVJxnE5gRwGilsSg0o,1553
 praisonai/ui/public/game.svg,sha256=y2QMaA01m8XzuDjTOBWzupOC3-TpnUl9ah89mIhviUw,2406
@@ -45,10 +45,10 @@ praisonai/ui/realtime.py,sha256=qpgcGA8CIUfYuSXtQM0zSlxktFtUZXsryn0Tru-R5wU,1530
 praisonai/ui/realtimeclient/__init__.py,sha256=zA2xa7rBUSw77wFkndJMQNNPqdH6ywQ3uf4WSYHjNfs,27513
 praisonai/ui/realtimeclient/realtimedocs.txt,sha256=hmgd8Uwy2SkjSndyyF_-ZOaNxiyHwGaQLGc67DvV-sI,26395
 praisonai/ui/realtimeclient/tools.py,sha256=IJOYwVOBW5Ocn5_iV9pFkmSKR3WU3YpX3kwF0I3jikQ,7855
-praisonai/ui/sql_alchemy.py,sha256=kf025P_37C505YDDJZ-dPSmN_d62J2DCrkxbDAzXyrM,29884
+praisonai/ui/sql_alchemy.py,sha256=gFqeq70R7FyZyYnE_J0SzdhviVqzFJgplNG-2a0JH8I,29970
 praisonai/version.py,sha256=ugyuFliEqtAwQmH4sTlc16YXKYbFWDmfyk87fErB8-8,21
-praisonai-1.0.2.dist-info/LICENSE,sha256=kqvFysVlnFxYOu0HxCe2HlmZmJtdmNGOxWRRkT9TsWc,1035
-praisonai-1.0.2.dist-info/METADATA,sha256=UhXSbFJhl1lnF2lnQ9Lp0n685ayF9JwG6RNirW_OS1M,17085
-praisonai-1.0.2.dist-info/WHEEL,sha256=Ie8mbC-etDUh6aDhzdvvvp_A-4mQQX7whlOFBnSJhcE,110
-praisonai-1.0.2.dist-info/entry_points.txt,sha256=I_xc6a6MNTTfLxYmAxe0rgey0G-_hbY07oFW-ZDnkw4,135
-praisonai-1.0.2.dist-info/RECORD,,
+praisonai-1.0.4.dist-info/LICENSE,sha256=kqvFysVlnFxYOu0HxCe2HlmZmJtdmNGOxWRRkT9TsWc,1035
+praisonai-1.0.4.dist-info/METADATA,sha256=5o0ngmKMBz1vBcT31ArQPVZdJwNLO_oDJM8vMaxcGTk,17085
+praisonai-1.0.4.dist-info/WHEEL,sha256=Ie8mbC-etDUh6aDhzdvvvp_A-4mQQX7whlOFBnSJhcE,110
+praisonai-1.0.4.dist-info/entry_points.txt,sha256=I_xc6a6MNTTfLxYmAxe0rgey0G-_hbY07oFW-ZDnkw4,135
+praisonai-1.0.4.dist-info/RECORD,,