chainlit 1.1.0__py3-none-any.whl → 1.1.0rc0__py3-none-any.whl

chainlit/data/acl.py

@@ -5,12 +5,9 @@ from fastapi import HTTPException
 async def is_thread_author(username: str, thread_id: str):
     data_layer = get_data_layer()
     if not data_layer:
-        raise HTTPException(status_code=400, detail="Data layer not initialized")
+        raise HTTPException(status_code=401, detail="Unauthorized")
 
     thread_author = await data_layer.get_thread_author(thread_id)
-    
-    if not thread_author:
-        raise HTTPException(status_code=404, detail="Thread not found")
 
     if thread_author != username:
         raise HTTPException(status_code=401, detail="Unauthorized")

chainlit/data/sql_alchemy.py

@@ -39,11 +39,9 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         ssl_require: bool = False,
         storage_provider: Optional[BaseStorageClient] = None,
         user_thread_limit: Optional[int] = 1000,
-        show_logger: Optional[bool] = False,
     ):
         self._conninfo = conninfo
         self.user_thread_limit = user_thread_limit
-        self.show_logger = show_logger
         ssl_args = {}
         if ssl_require:
             # Create an SSL context to require an SSL connection
@@ -57,7 +55,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         self.async_session = sessionmaker(bind=self.engine, expire_on_commit=False, class_=AsyncSession)  # type: ignore
         if storage_provider:
             self.storage_provider: Optional[BaseStorageClient] = storage_provider
-            if self.show_logger: logger.info("SQLAlchemyDataLayer storage client initialized")
+            logger.info("SQLAlchemyDataLayer storage client initialized")
         else:
             self.storage_provider = None
             logger.warn(
@@ -104,7 +102,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### User ######
     async def get_user(self, identifier: str) -> Optional[PersistedUser]:
-        if self.show_logger: logger.info(f"SQLAlchemy: get_user, identifier={identifier}")
+        logger.info(f"SQLAlchemy: get_user, identifier={identifier}")
         query = "SELECT * FROM users WHERE identifier = :identifier"
         parameters = {"identifier": identifier}
         result = await self.execute_sql(query=query, parameters=parameters)
@@ -114,20 +112,20 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         return None
 
     async def create_user(self, user: User) -> Optional[PersistedUser]:
-        if self.show_logger: logger.info(f"SQLAlchemy: create_user, user_identifier={user.identifier}")
+        logger.info(f"SQLAlchemy: create_user, user_identifier={user.identifier}")
         existing_user: Optional["PersistedUser"] = await self.get_user(user.identifier)
         user_dict: Dict[str, Any] = {
             "identifier": str(user.identifier),
             "metadata": json.dumps(user.metadata) or {},
         }
         if not existing_user:  # create the user
-            if self.show_logger: logger.info("SQLAlchemy: create_user, creating the user")
+            logger.info("SQLAlchemy: create_user, creating the user")
             user_dict["id"] = str(uuid.uuid4())
             user_dict["createdAt"] = await self.get_current_timestamp()
             query = """INSERT INTO users ("id", "identifier", "createdAt", "metadata") VALUES (:id, :identifier, :createdAt, :metadata)"""
             await self.execute_sql(query=query, parameters=user_dict)
         else:  # update the user
-            if self.show_logger: logger.info("SQLAlchemy: update user metadata")
+            logger.info("SQLAlchemy: update user metadata")
             query = """UPDATE users SET "metadata" = :metadata WHERE "identifier" = :identifier"""
             await self.execute_sql(
                 query=query, parameters=user_dict
@@ -136,18 +134,19 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### Threads ######
     async def get_thread_author(self, thread_id: str) -> str:
-        if self.show_logger: logger.info(f"SQLAlchemy: get_thread_author, thread_id={thread_id}")
+        logger.info(f"SQLAlchemy: get_thread_author, thread_id={thread_id}")
         query = """SELECT "userIdentifier" FROM threads WHERE "id" = :id"""
         parameters = {"id": thread_id}
         result = await self.execute_sql(query=query, parameters=parameters)
         if isinstance(result, list) and result[0]:
             author_identifier = result[0].get("userIdentifier")
             if author_identifier is not None:
+                print(f"Author found: {author_identifier}")
                 return author_identifier
         raise ValueError(f"Author not found for thread_id {thread_id}")
 
     async def get_thread(self, thread_id: str) -> Optional[ThreadDict]:
-        if self.show_logger: logger.info(f"SQLAlchemy: get_thread, thread_id={thread_id}")
+        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
         )
@@ -164,7 +163,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         metadata: Optional[Dict] = None,
         tags: Optional[List[str]] = None,
     ):
-        if self.show_logger: logger.info(f"SQLAlchemy: update_thread, thread_id={thread_id}")
+        logger.info(f"SQLAlchemy: update_thread, thread_id={thread_id}")
         if context.session.user is not None:
             user_identifier = context.session.user.identifier
         else:
@@ -201,7 +200,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         await self.execute_sql(query=query, parameters=parameters)
 
     async def delete_thread(self, thread_id: str):
-        if self.show_logger: logger.info(f"SQLAlchemy: delete_thread, thread_id={thread_id}")
+        logger.info(f"SQLAlchemy: delete_thread, thread_id={thread_id}")
         # Delete feedbacks/elements/steps/thread
         feedbacks_query = """DELETE FROM feedbacks WHERE "forId" IN (SELECT "id" FROM steps WHERE "threadId" = :id)"""
         elements_query = """DELETE FROM elements WHERE "threadId" = :id"""
@@ -216,7 +215,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     async def list_threads(
         self, pagination: Pagination, filters: ThreadFilter
     ) -> PaginatedResponse:
-        if self.show_logger: logger.info(
+        logger.info(
             f"SQLAlchemy: list_threads, pagination={pagination}, filters={filters}"
         )
         if not filters.userId:
@@ -276,7 +275,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     ###### Steps ######
     @queue_until_user_message()
     async def create_step(self, step_dict: "StepDict"):
-        if self.show_logger: logger.info(f"SQLAlchemy: create_step, step_id={step_dict.get('id')}")
+        logger.info(f"SQLAlchemy: create_step, step_id={step_dict.get('id')}")
         if not getattr(context.session.user, "id", None):
             raise ValueError("No authenticated user in context")
         step_dict["showInput"] = (
@@ -306,12 +305,12 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     @queue_until_user_message()
     async def update_step(self, step_dict: "StepDict"):
-        if self.show_logger: logger.info(f"SQLAlchemy: update_step, step_id={step_dict.get('id')}")
+        logger.info(f"SQLAlchemy: update_step, step_id={step_dict.get('id')}")
         await self.create_step(step_dict)
 
     @queue_until_user_message()
     async def delete_step(self, step_id: str):
-        if self.show_logger: logger.info(f"SQLAlchemy: delete_step, step_id={step_id}")
+        logger.info(f"SQLAlchemy: delete_step, step_id={step_id}")
         # Delete feedbacks/elements/steps
         feedbacks_query = """DELETE FROM feedbacks WHERE "forId" = :id"""
         elements_query = """DELETE FROM elements WHERE "forId" = :id"""
@@ -323,7 +322,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### Feedback ######
     async def upsert_feedback(self, feedback: Feedback) -> str:
-        if self.show_logger: logger.info(f"SQLAlchemy: upsert_feedback, feedback_id={feedback.id}")
+        logger.info(f"SQLAlchemy: upsert_feedback, feedback_id={feedback.id}")
         feedback.id = feedback.id or str(uuid.uuid4())
         feedback_dict = asdict(feedback)
         parameters = {
@@ -345,7 +344,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         return feedback.id
 
     async def delete_feedback(self, feedback_id: str) -> bool:
-        if self.show_logger: logger.info(f"SQLAlchemy: delete_feedback, feedback_id={feedback_id}")
+        logger.info(f"SQLAlchemy: delete_feedback, feedback_id={feedback_id}")
         query = """DELETE FROM feedbacks WHERE "id" = :feedback_id"""
         parameters = {"feedback_id": feedback_id}
         await self.execute_sql(query=query, parameters=parameters)
@@ -354,7 +353,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     ###### Elements ######
     @queue_until_user_message()
     async def create_element(self, element: "Element"):
-        if self.show_logger: logger.info(f"SQLAlchemy: create_element, element_id = {element.id}")
+        logger.info(f"SQLAlchemy: create_element, element_id = {element.id}")
         if not getattr(context.session.user, "id", None):
             raise ValueError("No authenticated user in context")
         if isinstance(element, Avatar):  # Skip creating elements of type avatar
@@ -417,7 +416,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     @queue_until_user_message()
     async def delete_element(self, element_id: str):
-        if self.show_logger: logger.info(f"SQLAlchemy: delete_element, element_id={element_id}")
+        logger.info(f"SQLAlchemy: delete_element, element_id={element_id}")
         query = """DELETE FROM elements WHERE "id" = :id"""
         parameters = {"id": element_id}
         await self.execute_sql(query=query, parameters=parameters)
@@ -429,7 +428,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         self, user_id: Optional[str] = None, thread_id: Optional[str] = None
     ) -> Optional[List[ThreadDict]]:
         """Fetch all user threads up to self.user_thread_limit, or one thread by id if thread_id is provided."""
-        if self.show_logger: logger.info(f"SQLAlchemy: get_all_user_threads")
+        logger.info(f"SQLAlchemy: get_all_user_threads")
         user_threads_query = """
             SELECT
                 "id" AS thread_id,
@@ -563,8 +562,8 @@ class SQLAlchemyDataLayer(BaseDataLayer):
                         tags=step_feedback.get("step_tags"),
                         input=(
                             step_feedback.get("step_input", "")
-                            if step_feedback["step_showinput"] == "true" 
-                            else None
+                            if step_feedback["step_showinput"]
+                            else ""
                         ),
                         output=step_feedback.get("step_output", ""),
                         createdAt=step_feedback.get("step_createdat"),

chainlit/element.py

@@ -5,7 +5,6 @@ from io import BytesIO
 from typing import Any, ClassVar, List, Literal, Optional, TypedDict, TypeVar, Union
 
 import filetype
-import mimetypes
 from chainlit.context import context
 from chainlit.data import get_data_layer
 from chainlit.logger import logger
@@ -166,16 +165,14 @@ class Element:
                 if self.type in mime_types
                 else filetype.guess_mime(self.path or self.content)
             )
-            if not self.mime and self.url:
-                self.mime = mimetypes.guess_type(self.url)[0]
-            
+
         await self._create()
 
         if not self.url and not self.chainlit_key:
             raise ValueError("Must provide url or chainlit key to send element")
 
         trace_event(f"send {self.__class__.__name__}")
-        await context.emitter.send_element(self.to_dict())
+        await context.emitter.emit("element", self.to_dict())
 
 
 ElementBased = TypeVar("ElementBased", bound=Element)

chainlit/emitter.py

@@ -4,10 +4,10 @@ from typing import Any, Dict, List, Literal, Optional, Union, cast
 
 from chainlit.config import config
 from chainlit.data import get_data_layer
-from chainlit.element import Element, ElementDict, File
+from chainlit.element import Element, File
 from chainlit.logger import logger
 from chainlit.message import Message
-from chainlit.session import BaseSession, HTTPSession, WebsocketSession
+from chainlit.session import BaseSession, WebsocketSession
 from chainlit.step import StepDict
 from chainlit.types import (
     AskActionResponse,
@@ -29,7 +29,6 @@ class BaseChainlitEmitter:
     """
 
     session: BaseSession
-    enabled: bool = True
 
     def __init__(self, session: BaseSession) -> None:
         """Initialize with the user session."""
@@ -47,10 +46,6 @@ class BaseChainlitEmitter:
         """Stub method to resume a thread."""
         pass
 
-    async def send_element(self, element_dict: ElementDict):
-        """Stub method to send an element to the UI."""
-        pass
-
     async def send_step(self, step_dict: StepDict):
         """Stub method to send a message to the UI."""
         pass
@@ -156,10 +151,6 @@ class ChainlitEmitter(BaseChainlitEmitter):
         """Send a thread to the UI to resume it"""
         return self.emit("resume_thread", thread_dict)
 
-    async def send_element(self, element_dict: ElementDict):
-        """Stub method to send an element to the UI."""
-        await self.emit("element", element_dict)
-
     def send_step(self, step_dict: StepDict):
         """Send a message to the UI."""
         return self.emit("new_message", step_dict)