langchain 0.3.23__py3-none-any.whl → 0.3.25__py3-none-any.whl

langchain/smith/evaluation/string_run_evaluator.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
+import uuid
 from abc import abstractmethod
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from langchain_core.callbacks.manager import (
     AsyncCallbackManagerForChainRun,
@@ -21,7 +22,7 @@ from langchain.evaluation.schema import StringEvaluator
 from langchain.schema import RUN_KEY
 
 
-def _get_messages_from_run_dict(messages: List[dict]) -> List[BaseMessage]:
+def _get_messages_from_run_dict(messages: list[dict]) -> list[BaseMessage]:
     if not messages:
         return []
     first_message = messages[0]
@@ -35,15 +36,15 @@ class StringRunMapper(Serializable):
     """Extract items to evaluate from the run object."""
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """The keys to extract from the run."""
         return ["prediction", "input"]
 
     @abstractmethod
-    def map(self, run: Run) -> Dict[str, str]:
+    def map(self, run: Run) -> dict[str, str]:
         """Maps the Run to a dictionary."""
 
-    def __call__(self, run: Run) -> Dict[str, str]:
+    def __call__(self, run: Run) -> dict[str, str]:
         """Maps the Run to a dictionary."""
         if not run.outputs:
             raise ValueError(f"Run {run.id} has no outputs to evaluate.")
@@ -53,7 +54,7 @@ class StringRunMapper(Serializable):
 class LLMStringRunMapper(StringRunMapper):
     """Extract items to evaluate from the run object."""
 
-    def serialize_chat_messages(self, messages: List[Dict]) -> str:
+    def serialize_chat_messages(self, messages: list[dict]) -> str:
         """Extract the input messages from the run."""
         if isinstance(messages, list) and messages:
             if isinstance(messages[0], dict):
@@ -66,7 +67,7 @@ class LLMStringRunMapper(StringRunMapper):
             return get_buffer_string(chat_messages)
         raise ValueError(f"Could not extract messages to evaluate {messages}")
 
-    def serialize_inputs(self, inputs: Dict) -> str:
+    def serialize_inputs(self, inputs: dict) -> str:
         if "prompts" in inputs:  # Should we even accept this?
             input_ = "\n\n".join(inputs["prompts"])
         elif "prompt" in inputs:
@@ -77,13 +78,13 @@ class LLMStringRunMapper(StringRunMapper):
             raise ValueError("LLM Run must have either messages or prompts as inputs.")
         return input_
 
-    def serialize_outputs(self, outputs: Dict) -> str:
+    def serialize_outputs(self, outputs: dict) -> str:
         if not outputs.get("generations"):
             raise ValueError("Cannot evaluate LLM Run without generations.")
-        generations: List[Dict] = outputs["generations"]
+        generations: list[dict] = outputs["generations"]
         if not generations:
             raise ValueError("Cannot evaluate LLM run with empty generations.")
-        first_generation: Dict = generations[0]
+        first_generation: dict = generations[0]
         if isinstance(first_generation, list):
             # Runs from Tracer have generations as a list of lists of dicts
             # Whereas Runs from the API have a list of dicts
@@ -94,7 +95,7 @@ class LLMStringRunMapper(StringRunMapper):
             output_ = first_generation["text"]
         return output_
 
-    def map(self, run: Run) -> Dict[str, str]:
+    def map(self, run: Run) -> dict[str, str]:
         """Maps the Run to a dictionary."""
         if run.run_type != "llm":
             raise ValueError("LLM RunMapper only supports LLM runs.")
@@ -135,7 +136,7 @@ class ChainStringRunMapper(StringRunMapper):
     If not provided, will use the only output key or raise an error
     if there are multiple."""
 
-    def _get_key(self, source: Dict, key: Optional[str], which: str) -> str:
+    def _get_key(self, source: dict, key: Optional[str], which: str) -> str:
         if key is not None:
             return source[key]
         elif len(source) == 1:
@@ -146,7 +147,7 @@ class ChainStringRunMapper(StringRunMapper):
                 f"{source}\nPlease manually specify a {which}_key"
             )
 
-    def map(self, run: Run) -> Dict[str, str]:
+    def map(self, run: Run) -> dict[str, str]:
         """Maps the Run to a dictionary."""
         if not run.outputs:
             raise ValueError(
@@ -182,7 +183,7 @@ class ChainStringRunMapper(StringRunMapper):
 class ToolStringRunMapper(StringRunMapper):
     """Map an input to the tool."""
 
-    def map(self, run: Run) -> Dict[str, str]:
+    def map(self, run: Run) -> dict[str, str]:
         if not run.outputs:
             raise ValueError(f"Run {run.id} has no outputs to evaluate.")
         return {"input": run.inputs["input"], "prediction": run.outputs["output"]}
@@ -194,16 +195,16 @@ class StringExampleMapper(Serializable):
     reference_key: Optional[str] = None
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """The keys to extract from the run."""
         return ["reference"]
 
-    def serialize_chat_messages(self, messages: List[Dict]) -> str:
+    def serialize_chat_messages(self, messages: list[dict]) -> str:
         """Extract the input messages from the run."""
         chat_messages = _get_messages_from_run_dict(messages)
         return get_buffer_string(chat_messages)
 
-    def map(self, example: Example) -> Dict[str, str]:
+    def map(self, example: Example) -> dict[str, str]:
         """Maps the Example, or dataset row to a dictionary."""
         if not example.outputs:
             raise ValueError(
@@ -230,7 +231,7 @@ class StringExampleMapper(Serializable):
             else output
         }
 
-    def __call__(self, example: Example) -> Dict[str, str]:
+    def __call__(self, example: Example) -> dict[str, str]:
         """Maps the Run and Example to a dictionary."""
         if not example.outputs:
             raise ValueError(
@@ -239,7 +240,7 @@ class StringExampleMapper(Serializable):
         return self.map(example)
 
 
-class StringRunEvaluatorChain(Chain, RunEvaluator):  # type: ignore[override, override]
+class StringRunEvaluatorChain(Chain, RunEvaluator):
     """Evaluate Run and optional examples."""
 
     run_mapper: StringRunMapper
@@ -253,14 +254,14 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):  # type: ignore[override, ov
     """The evaluation chain."""
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         return ["run", "example"]
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         return ["feedback"]
 
-    def _prepare_input(self, inputs: Dict[str, Any]) -> Dict[str, str]:
+    def _prepare_input(self, inputs: dict[str, Any]) -> dict[str, str]:
         run: Run = inputs["run"]
         example: Optional[Example] = inputs.get("example")
         evaluate_strings_inputs = self.run_mapper(run)
@@ -277,7 +278,7 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):  # type: ignore[override, ov
             )
         return evaluate_strings_inputs
 
-    def _prepare_output(self, output: Dict[str, Any]) -> Dict[str, Any]:
+    def _prepare_output(self, output: dict[str, Any]) -> dict[str, Any]:
         evaluation_result = EvaluationResult(
             key=self.name, comment=output.get("reasoning"), **output
         )
@@ -288,9 +289,9 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):  # type: ignore[override, ov
 
     def _call(
         self,
-        inputs: Dict[str, str],
+        inputs: dict[str, str],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Call the evaluation chain."""
         evaluate_strings_inputs = self._prepare_input(inputs)
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
@@ -304,9 +305,9 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):  # type: ignore[override, ov
 
     async def _acall(
         self,
-        inputs: Dict[str, str],
+        inputs: dict[str, str],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Call the evaluation chain."""
         evaluate_strings_inputs = self._prepare_input(inputs)
         _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
@@ -318,14 +319,17 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):  # type: ignore[override, ov
         )
         return self._prepare_output(chain_output)
 
-    def _prepare_evaluator_output(self, output: Dict[str, Any]) -> EvaluationResult:
+    def _prepare_evaluator_output(self, output: dict[str, Any]) -> EvaluationResult:
         feedback: EvaluationResult = output["feedback"]
         if RUN_KEY not in feedback.evaluator_info:
             feedback.evaluator_info[RUN_KEY] = output[RUN_KEY]
         return feedback
 
     def evaluate_run(
-        self, run: Run, example: Optional[Example] = None
+        self,
+        run: Run,
+        example: Optional[Example] = None,
+        evaluator_run_id: Optional[uuid.UUID] = None,
     ) -> EvaluationResult:
         """Evaluate an example."""
         try:
@@ -339,7 +343,10 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):  # type: ignore[override, ov
             )
 
     async def aevaluate_run(
-        self, run: Run, example: Optional[Example] = None
+        self,
+        run: Run,
+        example: Optional[Example] = None,
+        evaluator_run_id: Optional[uuid.UUID] = None,
     ) -> EvaluationResult:
         """Evaluate an example."""
         try:
@@ -362,7 +369,7 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):  # type: ignore[override, ov
         input_key: Optional[str] = None,
         prediction_key: Optional[str] = None,
         reference_key: Optional[str] = None,
-        tags: Optional[List[str]] = None,
+        tags: Optional[list[str]] = None,
     ) -> StringRunEvaluatorChain:
         """
         Create a StringRunEvaluatorChain from an evaluator and the run and dataset types.

langchain/storage/encoder_backed.py

@@ -1,12 +1,8 @@
+from collections.abc import AsyncIterator, Iterator, Sequence
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
-    Iterator,
-    List,
     Optional,
-    Sequence,
-    Tuple,
     TypeVar,
     Union,
 )
@@ -65,25 +61,25 @@ class EncoderBackedStore(BaseStore[K, V]):
         self.value_serializer = value_serializer
         self.value_deserializer = value_deserializer
 
-    def mget(self, keys: Sequence[K]) -> List[Optional[V]]:
+    def mget(self, keys: Sequence[K]) -> list[Optional[V]]:
         """Get the values associated with the given keys."""
-        encoded_keys: List[str] = [self.key_encoder(key) for key in keys]
+        encoded_keys: list[str] = [self.key_encoder(key) for key in keys]
         values = self.store.mget(encoded_keys)
         return [
             self.value_deserializer(value) if value is not None else value
             for value in values
         ]
 
-    async def amget(self, keys: Sequence[K]) -> List[Optional[V]]:
+    async def amget(self, keys: Sequence[K]) -> list[Optional[V]]:
         """Get the values associated with the given keys."""
-        encoded_keys: List[str] = [self.key_encoder(key) for key in keys]
+        encoded_keys: list[str] = [self.key_encoder(key) for key in keys]
         values = await self.store.amget(encoded_keys)
         return [
             self.value_deserializer(value) if value is not None else value
             for value in values
         ]
 
-    def mset(self, key_value_pairs: Sequence[Tuple[K, V]]) -> None:
+    def mset(self, key_value_pairs: Sequence[tuple[K, V]]) -> None:
         """Set the values for the given keys."""
         encoded_pairs = [
             (self.key_encoder(key), self.value_serializer(value))
@@ -91,7 +87,7 @@ class EncoderBackedStore(BaseStore[K, V]):
         ]
         self.store.mset(encoded_pairs)
 
-    async def amset(self, key_value_pairs: Sequence[Tuple[K, V]]) -> None:
+    async def amset(self, key_value_pairs: Sequence[tuple[K, V]]) -> None:
         """Set the values for the given keys."""
         encoded_pairs = [
             (self.key_encoder(key), self.value_serializer(value))

langchain/storage/file_system.py

@@ -1,8 +1,9 @@
 import os
 import re
 import time
+from collections.abc import Iterator, Sequence
 from pathlib import Path
-from typing import Iterator, List, Optional, Sequence, Tuple, Union
+from typing import Optional, Union
 
 from langchain_core.stores import ByteStore
 
@@ -103,7 +104,7 @@ class LocalFileStore(ByteStore):
             if self.chmod_dir is not None:
                 os.chmod(dir, self.chmod_dir)
 
-    def mget(self, keys: Sequence[str]) -> List[Optional[bytes]]:
+    def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
         """Get the values associated with the given keys.
 
         Args:
@@ -113,7 +114,7 @@ class LocalFileStore(ByteStore):
             A sequence of optional values associated with the keys.
             If a key is not found, the corresponding value will be None.
         """
-        values: List[Optional[bytes]] = []
+        values: list[Optional[bytes]] = []
         for key in keys:
             full_path = self._get_full_path(key)
             if full_path.exists():
@@ -126,7 +127,7 @@ class LocalFileStore(ByteStore):
                 values.append(None)
         return values
 
-    def mset(self, key_value_pairs: Sequence[Tuple[str, bytes]]) -> None:
+    def mset(self, key_value_pairs: Sequence[tuple[str, bytes]]) -> None:
         """Set the values for the given keys.
 
         Args:

{langchain-0.3.23.dist-info → langchain-0.3.25.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: langchain
-Version: 0.3.23
+Version: 0.3.25
 Summary: Building applications with LLMs through composability
 License: MIT
 Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/langchain
 Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain%3D%3D0%22&expanded=true
 Project-URL: repository, https://github.com/langchain-ai/langchain
-Requires-Python: <4.0,>=3.9
-Requires-Dist: langchain-core<1.0.0,>=0.3.51
+Requires-Python: >=3.9
+Requires-Dist: langchain-core<1.0.0,>=0.3.58
 Requires-Dist: langchain-text-splitters<1.0.0,>=0.3.8
 Requires-Dist: langsmith<0.4,>=0.1.17
 Requires-Dist: pydantic<3.0.0,>=2.7.4