langchain-core 0.4.0.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain_core/tracers/langchain.py

@@ -5,10 +5,10 @@ from __future__ import annotations
 import logging
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any
 from uuid import UUID
 
-from langsmith import Client
+from langsmith import Client, get_tracing_context
 from langsmith import run_trees as rt
 from langsmith import utils as ls_utils
 from tenacity import (
@@ -21,19 +21,16 @@ from typing_extensions import override
 
 from langchain_core.env import get_runtime_environment
 from langchain_core.load import dumpd
-from langchain_core.messages.utils import convert_from_v1_message
 from langchain_core.tracers.base import BaseTracer
 from langchain_core.tracers.schemas import Run
-from langchain_core.v1.messages import MessageV1Types
 
 if TYPE_CHECKING:
     from langchain_core.messages import BaseMessage
     from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
-    from langchain_core.v1.messages import AIMessageChunk, MessageV1
 
 logger = logging.getLogger(__name__)
 _LOGGED = set()
-_EXECUTOR: Optional[ThreadPoolExecutor] = None
+_EXECUTOR: ThreadPoolExecutor | None = None
 
 
 def log_error_once(method: str, exception: Exception) -> None:
@@ -56,7 +53,11 @@ def wait_for_all_tracers() -> None:
 
 
 def get_client() -> Client:
-    """Get the client."""
+    """Get the client.
+
+    Returns:
+        The LangSmith client.
+    """
     return rt.get_cached_client()
 
 
@@ -75,10 +76,10 @@ class LangChainTracer(BaseTracer):
 
     def __init__(
         self,
-        example_id: Optional[Union[UUID, str]] = None,
-        project_name: Optional[str] = None,
-        client: Optional[Client] = None,
-        tags: Optional[list[str]] = None,
+        example_id: UUID | str | None = None,
+        project_name: str | None = None,
+        client: Client | None = None,
+        tags: list[str] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the LangChain tracer.
@@ -88,7 +89,7 @@ class LangChainTracer(BaseTracer):
             project_name: The project name. Defaults to the tracer project.
             client: The client. Defaults to the global client.
             tags: The tags. Defaults to an empty list.
-            kwargs: Additional keyword arguments.
+            **kwargs: Additional keyword arguments.
         """
         super().__init__(**kwargs)
         self.example_id = (
@@ -97,7 +98,7 @@ class LangChainTracer(BaseTracer):
         self.project_name = project_name or ls_utils.get_tracer_project()
         self.client = client or get_client()
         self.tags = tags or []
-        self.latest_run: Optional[Run] = None
+        self.latest_run: Run | None = None
         self.run_has_token_event_map: dict[str, bool] = {}
 
     def _start_trace(self, run: Run) -> None:
@@ -112,17 +113,19 @@ class LangChainTracer(BaseTracer):
         super()._start_trace(run)
         if run.ls_client is None:
             run.ls_client = self.client
+        if get_tracing_context().get("enabled") is False:
+            run.extra["__disabled"] = True
 
     def on_chat_model_start(
         self,
         serialized: dict[str, Any],
-        messages: Union[list[list[BaseMessage]], list[MessageV1]],
+        messages: list[list[BaseMessage]],
         *,
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> Run:
         """Start a trace for an LLM run.
@@ -131,24 +134,18 @@ class LangChainTracer(BaseTracer):
             serialized: The serialized model.
             messages: The messages.
             run_id: The run ID.
-            tags: The tags. Defaults to None.
-            parent_run_id: The parent run ID. Defaults to None.
-            metadata: The metadata. Defaults to None.
-            name: The name. Defaults to None.
-            kwargs: Additional keyword arguments.
+            tags: The tags.
+            parent_run_id: The parent run ID.
+            metadata: The metadata.
+            name: The name.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            Run: The run.
+            The run.
         """
         start_time = datetime.now(timezone.utc)
         if metadata:
             kwargs.update({"metadata": metadata})
-        if isinstance(messages[0], MessageV1Types):
-            # Convert from v1 messages to BaseMessage
-            messages = [
-                [convert_from_v1_message(msg) for msg in messages]  # type: ignore[arg-type]
-            ]
-        messages = cast("list[list[BaseMessage]]", messages)
         chat_model_run = Run(
             id=run_id,
             parent_run_id=parent_run_id,
@@ -178,7 +175,7 @@ class LangChainTracer(BaseTracer):
         """Get the LangSmith root run URL.
 
         Returns:
-            str: The LangSmith root run URL.
+            The LangSmith root run URL.
 
         Raises:
             ValueError: If no traced run is found.
@@ -210,6 +207,8 @@ class LangChainTracer(BaseTracer):
 
     def _persist_run_single(self, run: Run) -> None:
         """Persist a run."""
+        if run.extra.get("__disabled"):
+            return
         try:
             run.extra["runtime"] = get_runtime_environment()
             run.tags = self._get_tags(run)
@@ -223,6 +222,8 @@ class LangChainTracer(BaseTracer):
 
     def _update_run_single(self, run: Run) -> None:
         """Update a run."""
+        if run.extra.get("__disabled"):
+            return
         try:
             run.patch(exclude_inputs=run.extra.get("inputs_is_truthy", False))
         except Exception as e:
@@ -241,12 +242,9 @@ class LangChainTracer(BaseTracer):
         self,
         token: str,
         run_id: UUID,
-        chunk: Optional[
-            Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]
-        ] = None,
-        parent_run_id: Optional[UUID] = None,
+        chunk: GenerationChunk | ChatGenerationChunk | None = None,
+        parent_run_id: UUID | None = None,
     ) -> Run:
-        """Append token event to LLM run and return the run."""
         run_id_str = str(run_id)
         if run_id_str not in self.run_has_token_event_map:
             self.run_has_token_event_map[run_id_str] = True

langchain_core/tracers/log_stream.py

@@ -7,23 +7,23 @@ import contextlib
 import copy
 import threading
 from collections import defaultdict
+from pprint import pformat
 from typing import (
     TYPE_CHECKING,
     Any,
     Literal,
-    Optional,
     TypeVar,
-    Union,
     overload,
 )
 
 import jsonpatch  # type: ignore[import-untyped]
 from typing_extensions import NotRequired, TypedDict, override
 
+from langchain_core.callbacks.base import BaseCallbackManager
 from langchain_core.load import dumps
 from langchain_core.load.load import load
 from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
-from langchain_core.runnables import Runnable, RunnableConfig, ensure_config
+from langchain_core.runnables import RunnableConfig, ensure_config
 from langchain_core.tracers._streaming import _StreamingCallbackHandler
 from langchain_core.tracers.base import BaseTracer
 from langchain_core.tracers.memory_stream import _MemoryStream
@@ -32,9 +32,9 @@ if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator, Sequence
     from uuid import UUID
 
+    from langchain_core.runnables import Runnable
     from langchain_core.runnables.utils import Input, Output
     from langchain_core.tracers.schemas import Run
-    from langchain_core.v1.messages import AIMessageChunk
 
 
 class LogEntry(TypedDict):
@@ -57,13 +57,13 @@ class LogEntry(TypedDict):
     """List of LLM tokens streamed by this run, if applicable."""
     streamed_output: list[Any]
     """List of output chunks streamed by this run, if available."""
-    inputs: NotRequired[Optional[Any]]
+    inputs: NotRequired[Any | None]
     """Inputs to this run. Not available currently via astream_log."""
-    final_output: Optional[Any]
+    final_output: Any | None
     """Final output of this run.
 
     Only available after the run has finished successfully."""
-    end_time: Optional[str]
+    end_time: str | None
     """ISO-8601 timestamp of when the run ended.
     Only available after the run has finished."""
 
@@ -75,7 +75,7 @@ class RunState(TypedDict):
     """ID of the run."""
     streamed_output: list[Any]
     """List of output chunks streamed by Runnable.stream()"""
-    final_output: Optional[Any]
+    final_output: Any | None
     """Final output of the run, usually the result of aggregating (`+`) streamed_output.
     Updated throughout the run when supported by the Runnable."""
 
@@ -110,8 +110,18 @@ class RunLogPatch:
         """
         self.ops = list(ops)
 
-    def __add__(self, other: Union[RunLogPatch, Any]) -> RunLog:
-        """Combine two RunLogPatch instances."""
+    def __add__(self, other: RunLogPatch | Any) -> RunLog:
+        """Combine two `RunLogPatch` instances.
+
+        Args:
+            other: The other `RunLogPatch` to combine with.
+
+        Raises:
+            TypeError: If the other object is not a `RunLogPatch`.
+
+        Returns:
+            A new `RunLog` representing the combination of the two.
+        """
         if type(other) is RunLogPatch:
             ops = self.ops + other.ops
             state = jsonpatch.apply_patch(None, copy.deepcopy(ops))
@@ -122,8 +132,6 @@ class RunLogPatch:
 
     @override
     def __repr__(self) -> str:
-        from pprint import pformat
-
         # 1:-1 to get rid of the [] around the list
         return f"RunLogPatch({pformat(self.ops)[1:-1]})"
 
@@ -150,8 +158,18 @@ class RunLog(RunLogPatch):
         super().__init__(*ops)
         self.state = state
 
-    def __add__(self, other: Union[RunLogPatch, Any]) -> RunLog:
-        """Combine two RunLogs."""
+    def __add__(self, other: RunLogPatch | Any) -> RunLog:
+        """Combine two `RunLog`s.
+
+        Args:
+            other: The other `RunLog` or `RunLogPatch` to combine with.
+
+        Raises:
+            TypeError: If the other object is not a `RunLog` or `RunLogPatch`.
+
+        Returns:
+            A new `RunLog` representing the combination of the two.
+        """
         if type(other) is RunLogPatch:
             ops = self.ops + other.ops
             state = jsonpatch.apply_patch(self.state, other.ops)
@@ -162,13 +180,18 @@ class RunLog(RunLogPatch):
 
     @override
     def __repr__(self) -> str:
-        from pprint import pformat
-
         return f"RunLog({pformat(self.state)})"
 
     @override
     def __eq__(self, other: object) -> bool:
-        """Check if two RunLogs are equal."""
+        """Check if two `RunLog`s are equal.
+
+        Args:
+            other: The other `RunLog` to compare to.
+
+        Returns:
+            `True` if the `RunLog`s are equal, `False` otherwise.
+        """
         # First compare that the state is the same
         if not isinstance(other, RunLog):
             return False
@@ -177,7 +200,7 @@ class RunLog(RunLogPatch):
         # Then compare that the ops are the same
         return super().__eq__(other)
 
-    __hash__ = None  # type: ignore[assignment]
+    __hash__ = None
 
 
 T = TypeVar("T")
@@ -190,12 +213,12 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self,
         *,
         auto_close: bool = True,
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         # Schema format is for internal use only.
         _schema_format: Literal["original", "streaming_events"] = "streaming_events",
     ) -> None:
@@ -241,17 +264,24 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self.exclude_types = exclude_types
         self.exclude_tags = exclude_tags
 
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
         memory_stream = _MemoryStream[RunLogPatch](loop)
         self.lock = threading.Lock()
         self.send_stream = memory_stream.get_send_stream()
         self.receive_stream = memory_stream.get_receive_stream()
         self._key_map_by_run_id: dict[UUID, str] = {}
         self._counter_map_by_name: dict[str, int] = defaultdict(int)
-        self.root_id: Optional[UUID] = None
+        self.root_id: UUID | None = None
 
     def __aiter__(self) -> AsyncIterator[RunLogPatch]:
-        """Iterate over the stream of run logs."""
+        """Iterate over the stream of run logs.
+
+        Returns:
+            An async iterator over the run log patches.
+        """
         return self.receive_stream.__aiter__()
 
     def send(self, *ops: dict[str, Any]) -> bool:
@@ -261,8 +291,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
             *ops: The operations to send to the stream.
 
         Returns:
-            bool: True if the patch was sent successfully, False if the stream
-                is closed.
+            `True` if the patch was sent successfully, False if the stream is closed.
         """
         # We will likely want to wrap this in try / except at some point
         # to handle exceptions that might arise at run time.
@@ -281,7 +310,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
             output: The output async iterator.
 
         Yields:
-            T: The output value.
+            The output value.
         """
         async for chunk in output:
             # root run is handled in .astream_log()
@@ -312,7 +341,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
             output: The output iterator.
 
         Yields:
-            T: The output value.
+            The output value.
         """
         for chunk in output:
             # root run is handled in .astream_log()
@@ -342,7 +371,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
             run: The Run to check.
 
         Returns:
-            bool: True if the run should be included, False otherwise.
+            `True` if the run should be included, `False` otherwise.
         """
         if run.id == self.root_id:
             return False
@@ -486,7 +515,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self,
         run: Run,
         token: str,
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]],
+        chunk: GenerationChunk | ChatGenerationChunk | None,
     ) -> None:
         """Process new LLM token."""
         index = self._key_map_by_run_id.get(run.id)
@@ -512,7 +541,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
 
 def _get_standardized_inputs(
     run: Run, schema_format: Literal["original", "streaming_events"]
-) -> Optional[dict[str, Any]]:
+) -> dict[str, Any] | None:
     """Extract standardized inputs from a run.
 
     Standardizes the inputs based on the type of the runnable used.
@@ -554,7 +583,7 @@ def _get_standardized_inputs(
 
 def _get_standardized_outputs(
     run: Run, schema_format: Literal["original", "streaming_events", "original+chat"]
-) -> Optional[Any]:
+) -> Any | None:
     """Extract standardized output from a run.
 
     Standardizes the outputs based on the type of the runnable used.
@@ -588,7 +617,7 @@ def _get_standardized_outputs(
 def _astream_log_implementation(
     runnable: Runnable[Input, Output],
     value: Any,
-    config: Optional[RunnableConfig] = None,
+    config: RunnableConfig | None = None,
     *,
     stream: LogStreamCallbackHandler,
     diff: Literal[True] = True,
@@ -601,7 +630,7 @@ def _astream_log_implementation(
 def _astream_log_implementation(
     runnable: Runnable[Input, Output],
     value: Any,
-    config: Optional[RunnableConfig] = None,
+    config: RunnableConfig | None = None,
     *,
     stream: LogStreamCallbackHandler,
     diff: Literal[False],
@@ -613,26 +642,35 @@ def _astream_log_implementation(
 async def _astream_log_implementation(
     runnable: Runnable[Input, Output],
     value: Any,
-    config: Optional[RunnableConfig] = None,
+    config: RunnableConfig | None = None,
     *,
     stream: LogStreamCallbackHandler,
     diff: bool = True,
     with_streamed_output_list: bool = True,
     **kwargs: Any,
-) -> Union[AsyncIterator[RunLogPatch], AsyncIterator[RunLog]]:
+) -> AsyncIterator[RunLogPatch] | AsyncIterator[RunLog]:
     """Implementation of astream_log for a given runnable.
 
     The implementation has been factored out (at least temporarily) as both
     astream_log and astream_events relies on it.
-    """
-    import jsonpatch
-
-    from langchain_core.callbacks.base import BaseCallbackManager
-    from langchain_core.tracers.log_stream import (
-        RunLog,
-        RunLogPatch,
-    )
 
+    Args:
+        runnable: The runnable to run in streaming mode.
+        value: The input to the runnable.
+        config: The config to pass to the runnable.
+        stream: The stream to send the run logs to.
+        diff: Whether to yield run log patches (True) or full run logs (False).
+        with_streamed_output_list: Whether to include a list of all streamed
+            outputs in each patch. If `False`, only the final output will be included
+            in the patches.
+        **kwargs: Additional keyword arguments to pass to the runnable.
+
+    Raises:
+        ValueError: If the callbacks in the config are of an unexpected type.
+
+    Yields:
+        The run log patches or states, depending on the value of `diff`.
+    """
     # Assign the stream handler to the config
     config = ensure_config(config)
     callbacks = config.get("callbacks")
@@ -655,8 +693,8 @@ async def _astream_log_implementation(
     # add each chunk to the output stream
     async def consume_astream() -> None:
         try:
-            prev_final_output: Optional[Output] = None
-            final_output: Optional[Output] = None
+            prev_final_output: Output | None = None
+            final_output: Output | None = None
 
             async for chunk in runnable.astream(value, config, **kwargs):
                 prev_final_output = final_output

langchain_core/tracers/memory_stream.py

@@ -5,7 +5,7 @@ channel. The writer and reader can be in the same event loop or in different eve
 loops. When they're in different event loops, they will also be in different
 threads.
 
-This is useful in situations when there's a mix of synchronous and asynchronous
+Useful in situations when there's a mix of synchronous and asynchronous
 used in the code.
 """
 
@@ -130,7 +130,7 @@ class _MemoryStream(Generic[T]):
         """Get a writer for the channel.
 
         Returns:
-            _SendStream: The writer for the channel.
+            The writer for the channel.
         """
         return _SendStream[T](
             reader_loop=self._loop, queue=self._queue, done=self._done
@@ -140,6 +140,6 @@ class _MemoryStream(Generic[T]):
         """Get a reader for the channel.
 
         Returns:
-            _ReceiveStream: The reader for the channel.
+            The reader for the channel.
         """
         return _ReceiveStream[T](queue=self._queue, done=self._done)

langchain_core/tracers/root_listeners.py

@@ -1,7 +1,7 @@
 """Tracers that call listeners."""
 
-from collections.abc import Awaitable
-from typing import TYPE_CHECKING, Callable, Optional, Union
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING
 
 from langchain_core.runnables.config import (
     RunnableConfig,
@@ -14,33 +14,25 @@ from langchain_core.tracers.schemas import Run
 if TYPE_CHECKING:
     from uuid import UUID
 
-Listener = Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-AsyncListener = Union[
-    Callable[[Run], Awaitable[None]], Callable[[Run, RunnableConfig], Awaitable[None]]
-]
+Listener = Callable[[Run], None] | Callable[[Run, RunnableConfig], None]
+AsyncListener = (
+    Callable[[Run], Awaitable[None]] | Callable[[Run, RunnableConfig], Awaitable[None]]
+)
 
 
 class RootListenersTracer(BaseTracer):
-    """Tracer that calls listeners on run start, end, and error.
-
-    Parameters:
-        log_missing_parent: Whether to log a warning if the parent is missing.
-            Default is False.
-        config: The runnable config.
-        on_start: The listener to call on run start.
-        on_end: The listener to call on run end.
-        on_error: The listener to call on run error.
-    """
+    """Tracer that calls listeners on run start, end, and error."""
 
     log_missing_parent = False
+    """Whether to log a warning if the parent is missing."""
 
     def __init__(
         self,
         *,
         config: RunnableConfig,
-        on_start: Optional[Listener],
-        on_end: Optional[Listener],
-        on_error: Optional[Listener],
+        on_start: Listener | None,
+        on_end: Listener | None,
+        on_error: Listener | None,
     ) -> None:
         """Initialize the tracer.
 
@@ -56,7 +48,7 @@ class RootListenersTracer(BaseTracer):
         self._arg_on_start = on_start
         self._arg_on_end = on_end
         self._arg_on_error = on_error
-        self.root_id: Optional[UUID] = None
+        self.root_id: UUID | None = None
 
     def _persist_run(self, run: Run) -> None:
         # This is a legacy method only called once for an entire run tree
@@ -84,26 +76,18 @@ class RootListenersTracer(BaseTracer):
 
 
 class AsyncRootListenersTracer(AsyncBaseTracer):
-    """Async Tracer that calls listeners on run start, end, and error.
-
-    Parameters:
-        log_missing_parent: Whether to log a warning if the parent is missing.
-            Default is False.
-        config: The runnable config.
-        on_start: The listener to call on run start.
-        on_end: The listener to call on run end.
-        on_error: The listener to call on run error.
-    """
+    """Async Tracer that calls listeners on run start, end, and error."""
 
     log_missing_parent = False
+    """Whether to log a warning if the parent is missing."""
 
     def __init__(
         self,
         *,
         config: RunnableConfig,
-        on_start: Optional[AsyncListener],
-        on_end: Optional[AsyncListener],
-        on_error: Optional[AsyncListener],
+        on_start: AsyncListener | None,
+        on_end: AsyncListener | None,
+        on_error: AsyncListener | None,
     ) -> None:
         """Initialize the tracer.
 
@@ -119,7 +103,7 @@ class AsyncRootListenersTracer(AsyncBaseTracer):
         self._arg_on_start = on_start
         self._arg_on_end = on_end
         self._arg_on_error = on_error
-        self.root_id: Optional[UUID] = None
+        self.root_id: UUID | None = None
 
     async def _persist_run(self, run: Run) -> None:
         # This is a legacy method only called once for an entire run tree

langchain_core/tracers/run_collector.py

@@ -1,6 +1,6 @@
 """A tracer that collects all nested runs in a list."""
 
-from typing import Any, Optional, Union
+from typing import Any
 from uuid import UUID
 
 from langchain_core.tracers.base import BaseTracer
@@ -11,27 +11,17 @@ class RunCollectorCallbackHandler(BaseTracer):
     """Tracer that collects all nested runs in a list.
 
     This tracer is useful for inspection and evaluation purposes.
-
-    Parameters
-    ----------
-    name : str, default="run-collector_callback_handler"
-    example_id : Optional[Union[UUID, str]], default=None
-        The ID of the example being traced. It can be either a UUID or a string.
     """
 
     name: str = "run-collector_callback_handler"
 
-    def __init__(
-        self, example_id: Optional[Union[UUID, str]] = None, **kwargs: Any
-    ) -> None:
+    def __init__(self, example_id: UUID | str | None = None, **kwargs: Any) -> None:
         """Initialize the RunCollectorCallbackHandler.
 
-        Parameters
-        ----------
-        example_id : Optional[Union[UUID, str]], default=None
-            The ID of the example being traced. It can be either a UUID or a string.
-        **kwargs : Any
-            Additional keyword arguments
+        Args:
+            example_id: The ID of the example being traced. (default: None).
+                It can be either a UUID or a string.
+            **kwargs: Additional keyword arguments.
         """
         super().__init__(**kwargs)
         self.example_id = (
@@ -42,10 +32,8 @@ class RunCollectorCallbackHandler(BaseTracer):
     def _persist_run(self, run: Run) -> None:
         """Persist a run by adding it to the traced_runs list.
 
-        Parameters
-        ----------
-        run : Run
-            The run to be persisted.
+        Args:
+            run: The run to be persisted.
         """
         run_ = run.copy()
         run_.reference_example_id = self.example_id