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

langchain_core/tracers/core.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import logging
-import sys
 import traceback
 from abc import ABC, abstractmethod
 from datetime import datetime, timezone
@@ -11,14 +10,11 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Literal,
-    Optional,
-    Union,
     cast,
 )
 
 from langchain_core.exceptions import TracerException
 from langchain_core.load import dumpd
-from langchain_core.messages.utils import convert_from_v1_message
 from langchain_core.outputs import (
     ChatGeneration,
     ChatGenerationChunk,
@@ -26,12 +22,6 @@ from langchain_core.outputs import (
     LLMResult,
 )
 from langchain_core.tracers.schemas import Run
-from langchain_core.v1.messages import (
-    AIMessage,
-    AIMessageChunk,
-    MessageV1,
-    MessageV1Types,
-)
 
 if TYPE_CHECKING:
     from collections.abc import Coroutine, Sequence
@@ -78,7 +68,7 @@ class _TracerCore(ABC):
                   for streaming events.
                 - 'original+chat' is a format that is the same as 'original'
                   except it does NOT raise an attribute error on_chat_model_start
-            kwargs: Additional keyword arguments that will be passed to
+            **kwargs: Additional keyword arguments that will be passed to
                 the superclass.
         """
         super().__init__(**kwargs)
@@ -89,7 +79,7 @@ class _TracerCore(ABC):
         """Map of run ID to (trace_id, dotted_order). Cleared when tracer GCed."""
 
     @abstractmethod
-    def _persist_run(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:
+    def _persist_run(self, run: Run) -> Coroutine[Any, Any, None] | None:
         """Persist a run."""
 
     @staticmethod
@@ -105,17 +95,12 @@ class _TracerCore(ABC):
         """Get the stacktrace of the parent error."""
         msg = repr(error)
         try:
-            if sys.version_info < (3, 10):
-                tb = traceback.format_exception(
-                    error.__class__, error, error.__traceback__
-                )
-            else:
-                tb = traceback.format_exception(error)
+            tb = traceback.format_exception(error)
             return (msg + "\n\n".join(tb)).strip()
         except:  # noqa: E722
             return msg
 
-    def _start_trace(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # type: ignore[return]
+    def _start_trace(self, run: Run) -> Coroutine[Any, Any, None] | None:  # type: ignore[return]
         current_dotted_order = run.start_time.strftime("%Y%m%dT%H%M%S%fZ") + str(run.id)
         if run.parent_run_id:
             if parent := self.order_map.get(run.parent_run_id):
@@ -139,9 +124,7 @@ class _TracerCore(ABC):
         self.order_map[run.id] = (run.trace_id, run.dotted_order)
         self.run_map[str(run.id)] = run
 
-    def _get_run(
-        self, run_id: UUID, run_type: Union[str, set[str], None] = None
-    ) -> Run:
+    def _get_run(self, run_id: UUID, run_type: str | set[str] | None = None) -> Run:
         try:
             run = self.run_map[str(run_id)]
         except KeyError as exc:
@@ -149,7 +132,7 @@ class _TracerCore(ABC):
             raise TracerException(msg) from exc
 
         if isinstance(run_type, str):
-            run_types: Union[set[str], None] = {run_type}
+            run_types: set[str] | None = {run_type}
         else:
             run_types = run_type
         if run_types is not None and run.run_type not in run_types:
@@ -163,12 +146,12 @@ class _TracerCore(ABC):
     def _create_chat_model_run(
         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:
         """Create a chat model run."""
@@ -188,12 +171,6 @@ class _TracerCore(ABC):
         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)
         return Run(
             id=run_id,
             parent_run_id=parent_run_id,
@@ -215,10 +192,10 @@ class _TracerCore(ABC):
         serialized: dict[str, Any],
         prompts: list[str],
         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:
         """Create a llm run."""
@@ -243,10 +220,8 @@ class _TracerCore(ABC):
         self,
         token: str,
         run_id: UUID,
-        chunk: Optional[
-            Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]
-        ] = None,
-        parent_run_id: Optional[UUID] = None,  # noqa: ARG002
+        chunk: GenerationChunk | ChatGenerationChunk | None = None,
+        parent_run_id: UUID | None = None,  # noqa: ARG002
     ) -> Run:
         """Append token event to LLM run and return the run."""
         llm_run = self._get_run(run_id, run_type={"llm", "chat_model"})
@@ -291,15 +266,7 @@ class _TracerCore(ABC):
         )
         return llm_run
 
-    def _complete_llm_run(
-        self, response: Union[LLMResult, AIMessage], run_id: UUID
-    ) -> Run:
-        if isinstance(response, AIMessage):
-            response = LLMResult(
-                generations=[
-                    [ChatGeneration(message=convert_from_v1_message(response))]
-                ]
-            )
+    def _complete_llm_run(self, response: LLMResult, run_id: UUID) -> Run:
         llm_run = self._get_run(run_id, run_type={"llm", "chat_model"})
         if getattr(llm_run, "outputs", None) is None:
             llm_run.outputs = {}
@@ -320,7 +287,7 @@ class _TracerCore(ABC):
         return llm_run
 
     def _errored_llm_run(
-        self, error: BaseException, run_id: UUID, response: Optional[LLMResult] = None
+        self, error: BaseException, run_id: UUID, response: LLMResult | None = None
     ) -> Run:
         llm_run = self._get_run(run_id, run_type={"llm", "chat_model"})
         llm_run.error = self._get_stacktrace(error)
@@ -348,11 +315,11 @@ class _TracerCore(ABC):
         serialized: dict[str, Any],
         inputs: dict[str, Any],
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        run_type: Optional[str] = None,
-        name: Optional[str] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        run_type: str | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> Run:
         """Create a chain Run."""
@@ -399,7 +366,7 @@ class _TracerCore(ABC):
         self,
         outputs: dict[str, Any],
         run_id: UUID,
-        inputs: Optional[dict[str, Any]] = None,
+        inputs: dict[str, Any] | None = None,
     ) -> Run:
         """Update a chain run with outputs and end time."""
         chain_run = self._get_run(run_id)
@@ -418,7 +385,7 @@ class _TracerCore(ABC):
     def _errored_chain_run(
         self,
         error: BaseException,
-        inputs: Optional[dict[str, Any]],
+        inputs: dict[str, Any] | None,
         run_id: UUID,
     ) -> Run:
         chain_run = self._get_run(run_id)
@@ -434,11 +401,11 @@ class _TracerCore(ABC):
         serialized: dict[str, Any],
         input_str: str,
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
-        inputs: Optional[dict[str, Any]] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
+        inputs: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Run:
         """Create a tool run."""
@@ -501,10 +468,10 @@ class _TracerCore(ABC):
         serialized: dict[str, Any],
         query: str,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> Run:
         """Create a retrieval run."""
@@ -554,82 +521,152 @@ class _TracerCore(ABC):
         return retrieval_run
 
     def __deepcopy__(self, memo: dict) -> _TracerCore:
-        """Deepcopy the tracer."""
+        """Return self deepcopied."""
         return self
 
     def __copy__(self) -> _TracerCore:
-        """Copy the tracer."""
+        """Return self copied."""
         return self
 
-    def _end_trace(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """End a trace for a run."""
+    def _end_trace(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """End a trace for a run.
+
+        Args:
+            run: The run.
+        """
         return None
 
-    def _on_run_create(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process a run upon creation."""
+    def _on_run_create(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process a run upon creation.
+
+        Args:
+            run: The created run.
+        """
         return None
 
-    def _on_run_update(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process a run upon update."""
+    def _on_run_update(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process a run upon update.
+
+        Args:
+            run: The updated run.
+        """
         return None
 
-    def _on_llm_start(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the LLM Run upon start."""
+    def _on_llm_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the LLM Run upon start.
+
+        Args:
+            run: The LLM run.
+        """
         return None
 
     def _on_llm_new_token(
         self,
         run: Run,  # noqa: ARG002
         token: str,  # noqa: ARG002
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]],  # noqa: ARG002
-    ) -> Union[None, Coroutine[Any, Any, None]]:
-        """Process new LLM token."""
+        chunk: GenerationChunk | ChatGenerationChunk | None,  # noqa: ARG002
+    ) -> Coroutine[Any, Any, None] | None:
+        """Process new LLM token.
+
+        Args:
+            run: The LLM run.
+            token: The new token.
+            chunk: Optional chunk.
+        """
         return None
 
-    def _on_llm_end(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the LLM Run."""
+    def _on_llm_end(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the LLM Run.
+
+        Args:
+            run: The LLM run.
+        """
         return None
 
-    def _on_llm_error(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the LLM Run upon error."""
+    def _on_llm_error(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the LLM Run upon error.
+
+        Args:
+            run: The LLM run.
+        """
         return None
 
-    def _on_chain_start(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Chain Run upon start."""
+    def _on_chain_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Chain Run upon start.
+
+        Args:
+            run: The chain run.
+        """
         return None
 
-    def _on_chain_end(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Chain Run."""
+    def _on_chain_end(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Chain Run.
+
+        Args:
+            run: The chain run.
+        """
         return None
 
-    def _on_chain_error(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Chain Run upon error."""
+    def _on_chain_error(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Chain Run upon error.
+
+        Args:
+            run: The chain run.
+        """
         return None
 
-    def _on_tool_start(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Tool Run upon start."""
+    def _on_tool_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Tool Run upon start.
+
+        Args:
+            run: The tool run.
+        """
         return None
 
-    def _on_tool_end(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Tool Run."""
+    def _on_tool_end(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Tool Run.
+
+        Args:
+            run: The tool run.
+        """
         return None
 
-    def _on_tool_error(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Tool Run upon error."""
+    def _on_tool_error(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Tool Run upon error.
+
+        Args:
+            run: The tool run.
+        """
         return None
 
-    def _on_chat_model_start(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Chat Model Run upon start."""
+    def _on_chat_model_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Chat Model Run upon start.
+
+        Args:
+            run: The chat model run.
+        """
         return None
 
-    def _on_retriever_start(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Retriever Run upon start."""
+    def _on_retriever_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Retriever Run upon start.
+
+        Args:
+            run: The retriever run.
+        """
         return None
 
-    def _on_retriever_end(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Retriever Run."""
+    def _on_retriever_end(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Retriever Run.
+
+        Args:
+            run: The retriever run.
+        """
         return None
 
-    def _on_retriever_error(self, run: Run) -> Union[None, Coroutine[Any, Any, None]]:  # noqa: ARG002
-        """Process the Retriever Run upon error."""
+    def _on_retriever_error(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
+        """Process the Retriever Run upon error.
+
+        Args:
+            run: The retriever run.
+        """
         return None

langchain_core/tracers/evaluation.py

@@ -6,7 +6,7 @@ import logging
 import threading
 import weakref
 from concurrent.futures import Future, ThreadPoolExecutor, wait
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, cast
 from uuid import UUID
 
 import langsmith
@@ -38,33 +38,36 @@ class EvaluatorCallbackHandler(BaseTracer):
     """Tracer that runs a run evaluator whenever a run is persisted.
 
     Attributes:
-        example_id : Union[UUID, None]
-            The example ID associated with the runs.
         client : Client
             The LangSmith client instance used for evaluating the runs.
-        evaluators : Sequence[RunEvaluator]
-            The sequence of run evaluators to be executed.
-        executor : ThreadPoolExecutor
-            The thread pool executor used for running the evaluators.
-        futures : set[Future]
-            The set of futures representing the running evaluators.
-        skip_unfinished : bool
-            Whether to skip runs that are not finished or raised
-            an error.
-        project_name : Optional[str]
-            The LangSmith project name to be organize eval chain runs under.
     """
 
     name: str = "evaluator_callback_handler"
+    example_id: UUID | None = None
+    """The example ID associated with the runs."""
+    client: langsmith.Client
+    """The LangSmith client instance used for evaluating the runs."""
+    evaluators: Sequence[langsmith.RunEvaluator] = ()
+    """The sequence of run evaluators to be executed."""
+    executor: ThreadPoolExecutor | None = None
+    """The thread pool executor used for running the evaluators."""
+    futures: weakref.WeakSet[Future] = weakref.WeakSet()
+    """The set of futures representing the running evaluators."""
+    skip_unfinished: bool = True
+    """Whether to skip runs that are not finished or raised an error."""
+    project_name: str | None = None
+    """The LangSmith project name to be organize eval chain runs under."""
+    logged_eval_results: dict[tuple[str, str], list[EvaluationResult]]
+    lock: threading.Lock
 
     def __init__(
         self,
         evaluators: Sequence[langsmith.RunEvaluator],
-        client: Optional[langsmith.Client] = None,
-        example_id: Optional[Union[UUID, str]] = None,
+        client: langsmith.Client | None = None,
+        example_id: UUID | str | None = None,
         skip_unfinished: bool = True,  # noqa: FBT001,FBT002
-        project_name: Optional[str] = "evaluators",
-        max_concurrency: Optional[int] = None,
+        project_name: str | None = "evaluators",
+        max_concurrency: int | None = None,
         **kwargs: Any,
     ) -> None:
         """Create an EvaluatorCallbackHandler.
@@ -91,7 +94,7 @@ class EvaluatorCallbackHandler(BaseTracer):
         self.client = client or langchain_tracer.get_client()
         self.evaluators = evaluators
         if max_concurrency is None:
-            self.executor: Optional[ThreadPoolExecutor] = _get_executor()
+            self.executor = _get_executor()
         elif max_concurrency > 0:
             self.executor = ThreadPoolExecutor(max_workers=max_concurrency)
             weakref.finalize(
@@ -100,10 +103,10 @@ class EvaluatorCallbackHandler(BaseTracer):
             )
         else:
             self.executor = None
-        self.futures: weakref.WeakSet[Future] = weakref.WeakSet()
+        self.futures = weakref.WeakSet()
         self.skip_unfinished = skip_unfinished
         self.project_name = project_name
-        self.logged_eval_results: dict[tuple[str, str], list[EvaluationResult]] = {}
+        self.logged_eval_results = {}
         self.lock = threading.Lock()
         _TRACERS.add(self)
 
@@ -111,12 +114,8 @@ class EvaluatorCallbackHandler(BaseTracer):
         """Evaluate the run in the project.
 
         Args:
-        ----------
-        run : Run
-            The run to be evaluated.
-        evaluator : RunEvaluator
-            The evaluator to use for evaluating the run.
-
+            run: The run to be evaluated.
+            evaluator: The evaluator to use for evaluating the run.
         """
         try:
             if self.project_name is None:
@@ -157,7 +156,7 @@ class EvaluatorCallbackHandler(BaseTracer):
 
     def _select_eval_results(
         self,
-        results: Union[EvaluationResult, EvaluationResults],
+        results: EvaluationResult | EvaluationResults,
     ) -> list[EvaluationResult]:
         if isinstance(results, EvaluationResult):
             results_ = [results]
@@ -173,9 +172,9 @@ class EvaluatorCallbackHandler(BaseTracer):
 
     def _log_evaluation_feedback(
         self,
-        evaluator_response: Union[EvaluationResult, EvaluationResults],
+        evaluator_response: EvaluationResult | EvaluationResults,
         run: Run,
-        source_run_id: Optional[UUID] = None,
+        source_run_id: UUID | None = None,
     ) -> list[EvaluationResult]:
         results = self._select_eval_results(evaluator_response)
         for res in results:
@@ -202,10 +201,7 @@ class EvaluatorCallbackHandler(BaseTracer):
         """Run the evaluator on the run.
 
         Args:
-        ----------
-        run : Run
-            The run to be evaluated.
-
+            run: The run to be evaluated.
         """
         if self.skip_unfinished and not run.outputs:
             logger.debug("Skipping unfinished run %s", run.id)