langchain-core 1.0.0a6__py3-none-any.whl → 1.0.4__py3-none-any.whl

langchain_core/tracers/langchain.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import logging
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 from uuid import UUID
 
 from langsmith import Client, get_tracing_context
@@ -30,7 +30,7 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 _LOGGED = set()
-_EXECUTOR: Optional[ThreadPoolExecutor] = None
+_EXECUTOR: ThreadPoolExecutor | None = None
 
 
 def log_error_once(method: str, exception: Exception) -> None:
@@ -76,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.
@@ -89,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 = (
@@ -98,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:
@@ -122,10 +122,10 @@ class LangChainTracer(BaseTracer):
         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.
@@ -134,14 +134,14 @@ 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:
@@ -175,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.
@@ -242,8 +242,8 @@ class LangChainTracer(BaseTracer):
         self,
         token: str,
         run_id: UUID,
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]] = None,
-        parent_run_id: Optional[UUID] = None,
+        chunk: GenerationChunk | ChatGenerationChunk | None = None,
+        parent_run_id: UUID | None = None,
     ) -> Run:
         run_id_str = str(run_id)
         if run_id_str not in self.run_has_token_event_map:

langchain_core/tracers/log_stream.py

@@ -12,9 +12,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Literal,
-    Optional,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -59,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."""
 
@@ -77,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."""
 
@@ -98,10 +96,10 @@ class RunLogPatch:
     """Patch to the run log."""
 
     ops: list[dict[str, Any]]
-    """List of jsonpatch operations, which describe how to create the run state
+    """List of JSONPatch operations, which describe how to create the run state
     from an empty dict. This is the minimal representation of the log, designed to
     be serialized as JSON and sent over the wire to reconstruct the log on the other
-    side. Reconstruction of the state can be done with any jsonpatch-compliant library,
+    side. Reconstruction of the state can be done with any JSONPatch-compliant library,
     see https://jsonpatch.com for more information."""
 
     def __init__(self, *ops: dict[str, Any]) -> None:
@@ -112,17 +110,17 @@ 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.
+            other: The other `RunLogPatch` to combine with.
 
         Raises:
-            TypeError: If the other object is not a ``RunLogPatch``.
+            TypeError: If the other object is not a `RunLogPatch`.
 
         Returns:
-            A new ``RunLog`` representing the combination of the two.
+            A new `RunLog` representing the combination of the two.
         """
         if type(other) is RunLogPatch:
             ops = self.ops + other.ops
@@ -160,17 +158,17 @@ class RunLog(RunLogPatch):
         super().__init__(*ops)
         self.state = state
 
-    def __add__(self, other: Union[RunLogPatch, Any]) -> RunLog:
-        """Combine two ``RunLog``s.
+    def __add__(self, other: RunLogPatch | Any) -> RunLog:
+        """Combine two `RunLog`s.
 
         Args:
-            other: The other ``RunLog`` or ``RunLogPatch`` to combine with.
+            other: The other `RunLog` or `RunLogPatch` to combine with.
 
         Raises:
-            TypeError: If the other object is not a ``RunLog`` or ``RunLogPatch``.
+            TypeError: If the other object is not a `RunLog` or `RunLogPatch`.
 
         Returns:
-            A new ``RunLog`` representing the combination of the two.
+            A new `RunLog` representing the combination of the two.
         """
         if type(other) is RunLogPatch:
             ops = self.ops + other.ops
@@ -186,13 +184,13 @@ class RunLog(RunLogPatch):
 
     @override
     def __eq__(self, other: object) -> bool:
-        """Check if two ``RunLog``s are equal.
+        """Check if two `RunLog`s are equal.
 
         Args:
-            other: The other ``RunLog`` to compare to.
+            other: The other `RunLog` to compare to.
 
         Returns:
-            True if the ``RunLog``s are equal, False otherwise.
+            `True` if the `RunLog`s are equal, `False` otherwise.
         """
         # First compare that the state is the same
         if not isinstance(other, RunLog):
@@ -215,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:
@@ -266,14 +264,17 @@ 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.
@@ -290,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.
@@ -310,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()
@@ -341,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()
@@ -371,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
@@ -515,7 +515,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self,
         run: Run,
         token: str,
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]],
+        chunk: GenerationChunk | ChatGenerationChunk | None,
     ) -> None:
         """Process new LLM token."""
         index = self._key_map_by_run_id.get(run.id)
@@ -541,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.
@@ -583,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.
@@ -617,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,
@@ -630,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],
@@ -642,13 +642,13 @@ 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
@@ -661,7 +661,7 @@ async def _astream_log_implementation(
         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
+            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.
 
@@ -669,7 +669,7 @@ async def _astream_log_implementation(
         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``.
+        The run log patches or states, depending on the value of `diff`.
     """
     # Assign the stream handler to the config
     config = ensure_config(config)
@@ -693,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,25 +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."""
 
     log_missing_parent = False
-    """Whether to log a warning if the parent is missing. Default is 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.
 
@@ -48,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
@@ -79,15 +79,15 @@ class AsyncRootListenersTracer(AsyncBaseTracer):
     """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. Default is 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.
 
@@ -103,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
@@ -15,9 +15,7 @@ class RunCollectorCallbackHandler(BaseTracer):
 
     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.
 
         Args:

langchain_core/tracers/schemas.py

@@ -2,142 +2,13 @@
 
 from __future__ import annotations
 
-import warnings
-from datetime import datetime, timezone
-from typing import Any, Optional
-from uuid import UUID
-
 from langsmith import RunTree
-from langsmith.schemas import RunTypeEnum as RunTypeEnumDep
-from pydantic import PydanticDeprecationWarning
-from pydantic.v1 import BaseModel as BaseModelV1
-from pydantic.v1 import Field as FieldV1
-
-from langchain_core._api import deprecated
-
-
-@deprecated("0.1.0", alternative="Use string instead.", removal="1.0")
-def RunTypeEnum() -> type[RunTypeEnumDep]:  # noqa: N802
-    """``RunTypeEnum``.
-
-    Returns:
-        The ``RunTypeEnum`` class.
-    """
-    warnings.warn(
-        "RunTypeEnum is deprecated. Please directly use a string instead"
-        " (e.g. 'llm', 'chain', 'tool').",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    return RunTypeEnumDep
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSessionV1Base(BaseModelV1):
-    """Base class for TracerSessionV1."""
-
-    start_time: datetime = FieldV1(default_factory=lambda: datetime.now(timezone.utc))
-    name: Optional[str] = None
-    extra: Optional[dict[str, Any]] = None
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSessionV1Create(TracerSessionV1Base):
-    """Create class for TracerSessionV1."""
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSessionV1(TracerSessionV1Base):
-    """TracerSessionV1 schema."""
-
-    id: int
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSessionBase(TracerSessionV1Base):
-    """Base class for TracerSession."""
-
-    tenant_id: UUID
-
-
-@deprecated("0.1.0", removal="1.0")
-class TracerSession(TracerSessionBase):
-    """TracerSessionV1 schema for the V2 API."""
-
-    id: UUID
-
-
-@deprecated("0.1.0", alternative="Run", removal="1.0")
-class BaseRun(BaseModelV1):
-    """Base class for Run."""
-
-    uuid: str
-    parent_uuid: Optional[str] = None
-    start_time: datetime = FieldV1(default_factory=lambda: datetime.now(timezone.utc))
-    end_time: datetime = FieldV1(default_factory=lambda: datetime.now(timezone.utc))
-    extra: Optional[dict[str, Any]] = None
-    execution_order: int
-    child_execution_order: int
-    serialized: dict[str, Any]
-    session_id: int
-    error: Optional[str] = None
-
-
-@deprecated("0.1.0", alternative="Run", removal="1.0")
-class LLMRun(BaseRun):
-    """Class for LLMRun."""
-
-    prompts: list[str]
-    # Temporarily, remove but we will completely remove LLMRun
-    # response: Optional[LLMResult] = None
-
-
-@deprecated("0.1.0", alternative="Run", removal="1.0")
-class ChainRun(BaseRun):
-    """Class for ChainRun."""
-
-    inputs: dict[str, Any]
-    outputs: Optional[dict[str, Any]] = None
-    child_llm_runs: list[LLMRun] = FieldV1(default_factory=list)
-    child_chain_runs: list[ChainRun] = FieldV1(default_factory=list)
-    child_tool_runs: list[ToolRun] = FieldV1(default_factory=list)
-
-
-@deprecated("0.1.0", alternative="Run", removal="1.0")
-class ToolRun(BaseRun):
-    """Class for ToolRun."""
-
-    tool_input: str
-    output: Optional[str] = None
-    action: str
-    child_llm_runs: list[LLMRun] = FieldV1(default_factory=list)
-    child_chain_runs: list[ChainRun] = FieldV1(default_factory=list)
-    child_tool_runs: list[ToolRun] = FieldV1(default_factory=list)
-
 
 # Begin V2 API Schemas
 
 
 Run = RunTree  # For backwards compatibility
 
-# TODO: Update once langsmith moves to Pydantic V2 and we can swap Run.model_rebuild
-# for Run.update_forward_refs
-with warnings.catch_warnings():
-    warnings.simplefilter("ignore", category=PydanticDeprecationWarning)
-
-    ChainRun.update_forward_refs()
-    ToolRun.update_forward_refs()
-
 __all__ = [
-    "BaseRun",
-    "ChainRun",
-    "LLMRun",
     "Run",
-    "RunTypeEnum",
-    "ToolRun",
-    "TracerSession",
-    "TracerSessionBase",
-    "TracerSessionV1",
-    "TracerSessionV1Base",
-    "TracerSessionV1Create",
 ]

langchain_core/tracers/stdout.py

@@ -1,7 +1,8 @@
 """Tracers that print to the console."""
 
 import json
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from langchain_core.tracers.base import BaseTracer
 from langchain_core.tracers.schemas import Run
@@ -48,8 +49,7 @@ class FunctionCallbackHandler(BaseTracer):
     """Tracer that calls a function with a single str parameter."""
 
     name: str = "function_callback_handler"
-    """The name of the tracer. This is used to identify the tracer in the logs.
-    Default is "function_callback_handler"."""
+    """The name of the tracer. This is used to identify the tracer in the logs."""
 
     def __init__(self, function: Callable[[str], None], **kwargs: Any) -> None:
         """Create a FunctionCallbackHandler.