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

chainlit/step.py

@@ -3,19 +3,44 @@ import inspect
 import json
 import time
 import uuid
+from copy import deepcopy
 from functools import wraps
 from typing import Callable, Dict, List, Optional, TypedDict, Union
 
+from literalai import BaseGeneration
+from literalai.helper import utc_now
+from literalai.observability.step import StepType, TrueStepType
+
 from chainlit.config import config
-from chainlit.context import context, local_steps
+from chainlit.context import CL_RUN_NAMES, context, local_steps
 from chainlit.data import get_data_layer
 from chainlit.element import Element
 from chainlit.logger import logger
 from chainlit.telemetry import trace_event
 from chainlit.types import FeedbackDict
-from literalai import BaseGeneration
-from literalai.helper import utc_now
-from literalai.step import StepType, TrueStepType
+
+
+def check_add_step_in_cot(step: "Step"):
+    is_message = step.type in [
+        "user_message",
+        "assistant_message",
+    ]
+    is_cl_run = step.name in CL_RUN_NAMES and step.type == "run"
+    if config.ui.cot == "hidden" and not is_message and not is_cl_run:
+        return False
+    return True
+
+
+def stub_step(step: "Step") -> "StepDict":
+    return {
+        "type": step.type,
+        "name": step.name,
+        "id": step.id,
+        "parentId": step.parent_id,
+        "threadId": step.thread_id,
+        "input": "",
+        "output": "",
+    }
 
 
 class StepDict(TypedDict, total=False):
@@ -24,11 +49,11 @@ class StepDict(TypedDict, total=False):
     id: str
     threadId: str
     parentId: Optional[str]
-    disableFeedback: bool
     streaming: bool
     waitForAnswer: Optional[bool]
     isError: Optional[bool]
     metadata: Dict
+    tags: Optional[List[str]]
     input: str
     output: str
     createdAt: Optional[str]
@@ -37,20 +62,26 @@ class StepDict(TypedDict, total=False):
     generation: Optional[Dict]
     showInput: Optional[Union[bool, str]]
     language: Optional[str]
-    indent: Optional[int]
     feedback: Optional[FeedbackDict]
 
 
+def flatten_args_kwargs(func, args, kwargs):
+    signature = inspect.signature(func)
+    bound_arguments = signature.bind(*args, **kwargs)
+    bound_arguments.apply_defaults()
+    return {k: deepcopy(v) for k, v in bound_arguments.arguments.items()}
+
+
 def step(
     original_function: Optional[Callable] = None,
     *,
     name: Optional[str] = "",
     type: TrueStepType = "undefined",
     id: Optional[str] = None,
-    disable_feedback: bool = True,
-    root: bool = False,
+    parent_id: Optional[str] = None,
+    tags: Optional[List[str]] = None,
     language: Optional[str] = None,
-    show_input: Union[bool, str] = False,
+    show_input: Union[bool, str] = "json",
 ):
     """Step decorator for async and sync functions."""
 
@@ -69,21 +100,22 @@ def step(
                     type=type,
                     name=name,
                     id=id,
-                    disable_feedback=disable_feedback,
-                    root=root,
+                    parent_id=parent_id,
+                    tags=tags,
                     language=language,
                     show_input=show_input,
                 ) as step:
                     try:
-                        step.input = {"args": args, "kwargs": kwargs}
-                    except:
-                        pass
+                        step.input = flatten_args_kwargs(func, args, kwargs)
+                    except Exception as e:
+                        logger.exception(e)
                     result = await func(*args, **kwargs)
                     try:
                         if result and not step.output:
                             step.output = result
-                    except:
-                        pass
+                    except Exception as e:
+                        step.is_error = True
+                        step.output = str(e)
                     return result
 
             return async_wrapper
@@ -95,21 +127,22 @@ def step(
                     type=type,
                     name=name,
                     id=id,
-                    disable_feedback=disable_feedback,
-                    root=root,
+                    parent_id=parent_id,
+                    tags=tags,
                     language=language,
                     show_input=show_input,
                 ) as step:
                     try:
-                        step.input = {"args": args, "kwargs": kwargs}
-                    except:
-                        pass
+                        step.input = flatten_args_kwargs(func, args, kwargs)
+                    except Exception as e:
+                        logger.exception(e)
                     result = func(*args, **kwargs)
                     try:
                         if result and not step.output:
                             step.output = result
-                    except:
-                        pass
+                    except Exception as e:
+                        step.is_error = True
+                        step.output = str(e)
                     return result
 
             return sync_wrapper
@@ -127,16 +160,15 @@ class Step:
     type: TrueStepType
     id: str
     parent_id: Optional[str]
-    disable_feedback: bool
 
     streaming: bool
     persisted: bool
 
-    root: bool
     show_input: Union[bool, str]
 
     is_error: Optional[bool]
     metadata: Dict
+    tags: Optional[List[str]]
     thread_id: str
     created_at: Union[str, None]
     start: Union[str, None]
@@ -153,25 +185,25 @@ class Step:
         id: Optional[str] = None,
         parent_id: Optional[str] = None,
         elements: Optional[List[Element]] = None,
-        disable_feedback: bool = True,
-        root: bool = False,
+        metadata: Optional[Dict] = None,
+        tags: Optional[List[str]] = None,
         language: Optional[str] = None,
-        show_input: Union[bool, str] = False,
+        show_input: Union[bool, str] = "json",
+        thread_id: Optional[str] = None,
     ):
         trace_event(f"init {self.__class__.__name__} {type}")
         time.sleep(0.001)
         self._input = ""
         self._output = ""
-        self.thread_id = context.session.thread_id
+        self.thread_id = thread_id or context.session.thread_id
         self.name = name or ""
         self.type = type
         self.id = id or str(uuid.uuid4())
-        self.disable_feedback = disable_feedback
-        self.metadata = {}
+        self.metadata = metadata or {}
+        self.tags = tags
         self.is_error = False
         self.show_input = show_input
         self.parent_id = parent_id
-        self.root = root
 
         self.language = language
         self.generation = None
@@ -185,22 +217,46 @@ class Step:
         self.persisted = False
         self.fail_on_persist_error = False
 
+    def _clean_content(self, content):
+        """
+        Recursively checks and converts bytes objects in content.
+        """
+
+        def handle_bytes(item):
+            if isinstance(item, bytes):
+                return "STRIPPED_BINARY_DATA"
+            elif isinstance(item, dict):
+                return {k: handle_bytes(v) for k, v in item.items()}
+            elif isinstance(item, list):
+                return [handle_bytes(i) for i in item]
+            elif isinstance(item, tuple):
+                return tuple(handle_bytes(i) for i in item)
+            return item
+
+        return handle_bytes(content)
+
     def _process_content(self, content, set_language=False):
         if content is None:
             return ""
-        if isinstance(content, dict):
+        content = self._clean_content(content)
+
+        if (
+            isinstance(content, dict)
+            or isinstance(content, list)
+            or isinstance(content, tuple)
+        ):
             try:
                 processed_content = json.dumps(content, indent=4, ensure_ascii=False)
                 if set_language:
                     self.language = "json"
             except TypeError:
-                processed_content = str(content)
+                processed_content = str(content).replace("\\n", "\n")
                 if set_language:
                     self.language = "text"
         elif isinstance(content, str):
             processed_content = content
         else:
-            processed_content = str(content)
+            processed_content = str(content).replace("\\n", "\n")
             if set_language:
                 self.language = "text"
         return processed_content
@@ -228,9 +284,9 @@ class Step:
             "id": self.id,
             "threadId": self.thread_id,
             "parentId": self.parent_id,
-            "disableFeedback": self.disable_feedback,
             "streaming": self.streaming,
             "metadata": self.metadata,
+            "tags": self.tags,
             "input": self.input,
             "isError": self.is_error,
             "output": self.output,
@@ -261,18 +317,15 @@ class Step:
             except Exception as e:
                 if self.fail_on_persist_error:
                     raise e
-                logger.error(f"Failed to persist step update: {str(e)}")
+                logger.error(f"Failed to persist step update: {e!s}")
 
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)
 
-        if config.ui.hide_cot and self.parent_id:
-            return
-
-        if not config.features.prompt_playground and "generation" in step_dict:
-            step_dict.pop("generation", None)
-
-        await context.emitter.update_step(step_dict)
+        if not check_add_step_in_cot(self):
+            await context.emitter.update_step(stub_step(self))
+        else:
+            await context.emitter.update_step(step_dict)
 
         return True
 
@@ -291,7 +344,7 @@ class Step:
             except Exception as e:
                 if self.fail_on_persist_error:
                     raise e
-                logger.error(f"Failed to persist step deletion: {str(e)}")
+                logger.error(f"Failed to persist step deletion: {e!s}")
 
         await context.emitter.delete_step(step_dict)
 
@@ -299,7 +352,7 @@ class Step:
 
     async def send(self):
         if self.persisted:
-            return
+            return self
 
         if config.code.author_rename:
             self.name = await config.code.author_rename(self.name)
@@ -318,45 +371,48 @@ class Step:
             except Exception as e:
                 if self.fail_on_persist_error:
                     raise e
-                logger.error(f"Failed to persist step creation: {str(e)}")
+                logger.error(f"Failed to persist step creation: {e!s}")
 
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)
 
-        if config.ui.hide_cot and self.parent_id:
-            return self.id
-
-        if not config.features.prompt_playground and "generation" in step_dict:
-            step_dict.pop("generation", None)
-
-        await context.emitter.send_step(step_dict)
+        if not check_add_step_in_cot(self):
+            await context.emitter.send_step(stub_step(self))
+        else:
+            await context.emitter.send_step(step_dict)
 
-        return self.id
+        return self
 
-    async def stream_token(self, token: str, is_sequence=False):
+    async def stream_token(self, token: str, is_sequence=False, is_input=False):
         """
         Sends a token to the UI.
         Once all tokens have been streamed, call .send() to end the stream and persist the step if persistence is enabled.
         """
-
-        if not self.streaming:
-            self.streaming = True
-            step_dict = self.to_dict()
-            await context.emitter.stream_start(step_dict)
-
         if is_sequence:
-            self.output = token
+            if is_input:
+                self.input = token
+            else:
+                self.output = token
         else:
-            self.output += token
+            if is_input:
+                self.input += token
+            else:
+                self.output += token
 
         assert self.id
 
-        if config.ui.hide_cot and self.parent_id:
+        if not check_add_step_in_cot(self):
+            await context.emitter.send_step(stub_step(self))
             return
 
-        await context.emitter.send_token(
-            id=self.id, token=token, is_sequence=is_sequence
-        )
+        if not self.streaming:
+            self.streaming = True
+            step_dict = self.to_dict()
+            await context.emitter.stream_start(step_dict)
+        else:
+            await context.emitter.send_token(
+                id=self.id, token=token, is_sequence=is_sequence, is_input=is_input
+            )
 
     # Handle parameter less decorator
     def __call__(self, func):
@@ -367,7 +423,6 @@ class Step:
             id=self.id,
             parent_id=self.parent_id,
             thread_id=self.thread_id,
-            disable_feedback=self.disable_feedback,
         )
 
     # Handle Context Manager Protocol
@@ -376,12 +431,9 @@ class Step:
         previous_steps = local_steps.get() or []
         parent_step = previous_steps[-1] if previous_steps else None
 
-        if not self.parent_id and not self.root:
+        if not self.parent_id:
             if parent_step:
                 self.parent_id = parent_step.id
-            elif context.session.root_message:
-                self.parent_id = context.session.root_message.id
-        context.active_steps.append(self)
         local_steps.set(previous_steps + [self])
         await self.send()
         return self
@@ -389,13 +441,14 @@ class Step:
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         self.end = utc_now()
 
-        if self in context.active_steps:
-            context.active_steps.remove(self)
+        if exc_type:
+            self.output = str(exc_val)
+            self.is_error = True
 
-        local_active_steps = local_steps.get()
-        if local_active_steps and self in local_active_steps:
-            local_active_steps.remove(self)
-            local_steps.set(local_active_steps)
+        current_steps = local_steps.get()
+        if current_steps and self in current_steps:
+            current_steps.remove(self)
+            local_steps.set(current_steps)
 
         await self.update()
 
@@ -405,12 +458,9 @@ class Step:
         previous_steps = local_steps.get() or []
         parent_step = previous_steps[-1] if previous_steps else None
 
-        if not self.parent_id and not self.root:
+        if not self.parent_id:
             if parent_step:
                 self.parent_id = parent_step.id
-            elif context.session.root_message:
-                self.parent_id = context.session.root_message.id
-        context.active_steps.append(self)
         local_steps.set(previous_steps + [self])
 
         asyncio.create_task(self.send())
@@ -418,12 +468,14 @@ class Step:
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.end = utc_now()
-        if self in context.active_steps:
-            context.active_steps.remove(self)
 
-        local_active_steps = local_steps.get()
-        if local_active_steps and self in local_active_steps:
-            local_active_steps.remove(self)
-            local_steps.set(local_active_steps)
+        if exc_type:
+            self.output = str(exc_val)
+            self.is_error = True
+
+        current_steps = local_steps.get()
+        if current_steps and self in current_steps:
+            current_steps.remove(self)
+            local_steps.set(current_steps)
 
         asyncio.create_task(self.update())

chainlit/sync.py

@@ -10,9 +10,10 @@ import asyncio
 import threading
 
 from asyncer import asyncify
-from chainlit.context import context_var
 from syncer import sync
 
+from chainlit.context import context_var
+
 make_async = asyncify
 
 T_Retval = TypeVar("T_Retval")

chainlit/teams/__init__.py

@@ -0,0 +1,6 @@
+import importlib.util
+
+if importlib.util.find_spec("botbuilder") is None:
+    raise ValueError(
+        "The botbuilder-core package is required to integrate Chainlit with a Slack app. Run `pip install botbuilder-core --upgrade`"
+    )