chainlit 1.0.401__py3-none-any.whl → 1.0.501__py3-none-any.whl

chainlit/data/__init__.py

@@ -2,7 +2,7 @@ import functools
 import json
 import os
 from collections import deque
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Dict, List, Literal, Optional, Union, cast
 
 import aiofiles
 from chainlit.config import config
@@ -10,21 +10,15 @@ from chainlit.context import context
 from chainlit.logger import logger
 from chainlit.session import WebsocketSession
 from chainlit.types import Feedback, Pagination, ThreadDict, ThreadFilter
-from chainlit.user import PersistedUser, User, UserDict
-from literalai import Attachment
-from literalai import Feedback as ClientFeedback
-from literalai import PageInfo, PaginatedResponse
-from literalai import Step as ClientStep
-from literalai.step import StepDict as ClientStepDict
-from literalai.thread import NumberListFilter, StringFilter, StringListFilter
-from literalai.thread import ThreadFilter as ClientThreadFilter
+from chainlit.user import PersistedUser, User
+from literalai import Attachment, PageInfo, PaginatedResponse, Score as LiteralScore, Step as LiteralStep
+from literalai.filter import threads_filters as LiteralThreadsFilters
+from literalai.step import StepDict as LiteralStepDict
 
 if TYPE_CHECKING:
     from chainlit.element import Element, ElementDict
     from chainlit.step import FeedbackDict, StepDict
 
-_data_layer = None
-
 
 def queue_until_user_message():
     def decorator(method):
@@ -59,6 +53,12 @@ class BaseDataLayer:
     async def create_user(self, user: "User") -> Optional["PersistedUser"]:
         pass
 
+    async def delete_feedback(
+        self,
+        feedback_id: str,
+    ) -> bool:
+        return True
+
     async def upsert_feedback(
         self,
         feedback: Feedback,
@@ -66,7 +66,7 @@ class BaseDataLayer:
         return ""
 
     @queue_until_user_message()
-    async def create_element(self, element_dict: "ElementDict"):
+    async def create_element(self, element: "Element"):
         pass
 
     async def get_element(
@@ -100,7 +100,8 @@ class BaseDataLayer:
         self, pagination: "Pagination", filters: "ThreadFilter"
     ) -> "PaginatedResponse[ThreadDict]":
         return PaginatedResponse(
-            data=[], pageInfo=PageInfo(hasNextPage=False, endCursor=None)
+            data=[],
+            pageInfo=PageInfo(hasNextPage=False, startCursor=None, endCursor=None),
         )
 
     async def get_thread(self, thread_id: str) -> "Optional[ThreadDict]":
@@ -120,11 +121,14 @@ class BaseDataLayer:
         return True
 
 
-class ChainlitDataLayer:
+_data_layer: Optional[BaseDataLayer] = None
+
+
+class ChainlitDataLayer(BaseDataLayer):
     def __init__(self, api_key: str, server: Optional[str]):
-        from literalai import LiteralClient
+        from literalai import AsyncLiteralClient
 
-        self.client = LiteralClient(api_key=api_key, url=server)
+        self.client = AsyncLiteralClient(api_key=api_key, url=server)
         logger.info("Chainlit data layer initialized")
 
     def attachment_to_element_dict(self, attachment: Attachment) -> "ElementDict":
@@ -145,20 +149,19 @@ class ChainlitDataLayer:
             "threadId": attachment.thread_id,
         }
 
-    def feedback_to_feedback_dict(
-        self, feedback: Optional[ClientFeedback]
+    def score_to_feedback_dict(
+        self, score: Optional[LiteralScore]
     ) -> "Optional[FeedbackDict]":
-        if not feedback:
+        if not score:
             return None
         return {
-            "id": feedback.id or "",
-            "forId": feedback.step_id or "",
-            "value": feedback.value or 0,  # type: ignore
-            "comment": feedback.comment,
-            "strategy": "BINARY",
+            "id": score.id or "",
+            "forId": score.step_id or "",
+            "value": cast(Literal[0, 1], score.value),
+            "comment": score.comment,
         }
 
-    def step_to_step_dict(self, step: ClientStep) -> "StepDict":
+    def step_to_step_dict(self, step: LiteralStep) -> "StepDict":
         metadata = step.metadata or {}
         input = (step.input or {}).get("content") or (
             json.dumps(step.input) if step.input and step.input != {} else ""
@@ -166,12 +169,26 @@ class ChainlitDataLayer:
         output = (step.output or {}).get("content") or (
             json.dumps(step.output) if step.output and step.output != {} else ""
         )
+
+        user_feedback = (
+            next(
+                (
+                    s
+                    for s in step.scores
+                    if s.type == "HUMAN" and s.name == "user-feedback"
+                ),
+                None,
+            )
+            if step.scores
+            else None
+        )
+
         return {
             "createdAt": step.created_at,
             "id": step.id or "",
             "threadId": step.thread_id or "",
             "parentId": step.parent_id,
-            "feedback": self.feedback_to_feedback_dict(step.feedback),
+            "feedback": self.score_to_feedback_dict(user_feedback),
             "start": step.start_time,
             "end": step.end_time,
             "type": step.type or "undefined",
@@ -185,7 +202,6 @@ class ChainlitDataLayer:
             "language": metadata.get("language"),
             "isError": metadata.get("isError", False),
             "waitForAnswer": metadata.get("waitForAnswer", False),
-            "feedback": self.feedback_to_feedback_dict(step.feedback),
         }
 
     async def get_user(self, identifier: str) -> Optional[PersistedUser]:
@@ -214,26 +230,37 @@ class ChainlitDataLayer:
             createdAt=_user.created_at or "",
         )
 
+    async def delete_feedback(
+        self,
+        feedback_id: str,
+    ):
+        if feedback_id:
+            await self.client.api.delete_score(
+                id=feedback_id,
+            )
+            return True
+        return False
+
     async def upsert_feedback(
         self,
         feedback: Feedback,
     ):
         if feedback.id:
-            await self.client.api.update_feedback(
+            await self.client.api.update_score(
                 id=feedback.id,
                 update_params={
                     "comment": feedback.comment,
-                    "strategy": feedback.strategy,
                     "value": feedback.value,
                 },
             )
             return feedback.id
         else:
-            created = await self.client.api.create_feedback(
+            created = await self.client.api.create_score(
                 step_id=feedback.forId,
                 value=feedback.value,
                 comment=feedback.comment,
-                strategy=feedback.strategy,
+                name="user-feedback",
+                type="HUMAN",
             )
             return created.id or ""
 
@@ -298,15 +325,18 @@ class ChainlitDataLayer:
 
     @queue_until_user_message()
     async def create_step(self, step_dict: "StepDict"):
-        metadata = {
-            "disableFeedback": step_dict.get("disableFeedback"),
-            "isError": step_dict.get("isError"),
-            "waitForAnswer": step_dict.get("waitForAnswer"),
-            "language": step_dict.get("language"),
-            "showInput": step_dict.get("showInput"),
-        }
+        metadata = dict(
+            step_dict.get("metadata", {}),
+            **{
+                "disableFeedback": step_dict.get("disableFeedback"),
+                "isError": step_dict.get("isError"),
+                "waitForAnswer": step_dict.get("waitForAnswer"),
+                "language": step_dict.get("language"),
+                "showInput": step_dict.get("showInput"),
+            },
+        )
 
-        step: ClientStepDict = {
+        step: LiteralStepDict = {
             "createdAt": step_dict.get("createdAt"),
             "startTime": step_dict.get("start"),
             "endTime": step_dict.get("end"),
@@ -316,6 +346,7 @@ class ChainlitDataLayer:
             "name": step_dict.get("name"),
             "threadId": step_dict.get("threadId"),
             "type": step_dict.get("type"),
+            "tags": step_dict.get("tags"),
             "metadata": metadata,
         }
         if step_dict.get("input"):
@@ -337,10 +368,11 @@ class ChainlitDataLayer:
         thread = await self.get_thread(thread_id)
         if not thread:
             return ""
-        user = thread.get("user")
-        if not user:
+        user_identifier = thread.get("userIdentifier")
+        if not user_identifier:
             return ""
-        return user.get("identifier") or ""
+
+        return user_identifier
 
     async def delete_thread(self, thread_id: str):
         await self.client.api.delete_thread(id=thread_id)
@@ -348,22 +380,42 @@ class ChainlitDataLayer:
     async def list_threads(
         self, pagination: "Pagination", filters: "ThreadFilter"
     ) -> "PaginatedResponse[ThreadDict]":
-        if not filters.userIdentifier:
-            raise ValueError("userIdentifier is required")
+        if not filters.userId:
+            raise ValueError("userId is required")
+
+        literal_filters: LiteralThreadsFilters = [
+            {
+                "field": "participantId",
+                "operator": "eq",
+                "value": filters.userId,
+            }
+        ]
 
-        client_filters = ClientThreadFilter(
-            participantsIdentifier=StringListFilter(
-                operator="in", value=[filters.userIdentifier]
-            ),
-        )
         if filters.search:
-            client_filters.search = StringFilter(operator="ilike", value=filters.search)
-        if filters.feedback:
-            client_filters.feedbacksValue = NumberListFilter(
-                operator="in", value=[filters.feedback]
+            literal_filters.append(
+                {
+                    "field": "stepOutput",
+                    "operator": "ilike",
+                    "value": filters.search,
+                    "path": "content",
+                }
             )
+
+        if filters.feedback is not None:
+            literal_filters.append(
+                {
+                    "field": "scoreValue",
+                    "operator": "eq",
+                    "value": filters.feedback,
+                    "path": "user-feedback",
+                }
+            )
+
         return await self.client.api.list_threads(
-            first=pagination.first, after=pagination.cursor, filters=client_filters
+            first=pagination.first,
+            after=pagination.cursor,
+            filters=literal_filters,
+            order_by={"column": "createdAt", "direction": "DESC"},
         )
 
     async def get_thread(self, thread_id: str) -> "Optional[ThreadDict]":
@@ -382,15 +434,6 @@ class ChainlitDataLayer:
                     step.generation = None
                 steps.append(self.step_to_step_dict(step))
 
-        user = None  # type: Optional["UserDict"]
-
-        if thread.user:
-            user = {
-                "id": thread.user.id or "",
-                "identifier": thread.user.identifier or "",
-                "metadata": thread.user.metadata,
-            }
-
         return {
             "createdAt": thread.created_at or "",
             "id": thread.id,
@@ -398,7 +441,8 @@ class ChainlitDataLayer:
             "steps": steps,
             "elements": elements,
             "metadata": thread.metadata,
-            "user": user,
+            "userId": thread.participant_id,
+            "userIdentifier": thread.participant_identifier,
             "tags": thread.tags,
         }
 
@@ -411,7 +455,7 @@ class ChainlitDataLayer:
         tags: Optional[List[str]] = None,
     ):
         await self.client.api.upsert_thread(
-            thread_id=thread_id,
+            id=thread_id,
             name=name,
             participant_id=user_id,
             metadata=metadata,
@@ -420,7 +464,8 @@ class ChainlitDataLayer:
 
 
 if api_key := os.environ.get("LITERAL_API_KEY"):
-    server = os.environ.get("LITERAL_SERVER")
+    # support legacy LITERAL_SERVER variable as fallback
+    server = os.environ.get("LITERAL_API_URL", os.environ.get("LITERAL_SERVER"))
     _data_layer = ChainlitDataLayer(api_key=api_key, server=server)