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

langchain/smith/evaluation/config.py

@@ -1,6 +1,7 @@
 """Configuration for run evaluators."""
 
-from typing import Any, Callable, Dict, List, Optional, Sequence, Union
+from collections.abc import Sequence
+from typing import Any, Callable, Optional, Union
 
 from langchain_core.embeddings import Embeddings
 from langchain_core.language_models import BaseLanguageModel
@@ -45,7 +46,7 @@ class EvalConfig(BaseModel):
 
     evaluator_type: EvaluatorType
 
-    def get_kwargs(self) -> Dict[str, Any]:
+    def get_kwargs(self) -> dict[str, Any]:
         """Get the keyword arguments for the load_evaluator call.
 
         Returns
@@ -78,7 +79,7 @@ class SingleKeyEvalConfig(EvalConfig):
     """The key from the traced run's inputs dictionary to use to represent the
     input. If not provided, it will be inferred automatically."""
 
-    def get_kwargs(self) -> Dict[str, Any]:
+    def get_kwargs(self) -> dict[str, Any]:
         kwargs = super().get_kwargs()
         # Filer out the keys that are not needed for the evaluator.
         for key in ["reference_key", "prediction_key", "input_key"]:
@@ -121,7 +122,7 @@ class RunEvalConfig(BaseModel):
         The language model to pass to any evaluators that use a language model.
     """  # noqa: E501
 
-    evaluators: List[
+    evaluators: list[
         Union[
             SINGLE_EVAL_CONFIG_TYPE,
             CUSTOM_EVALUATOR_TYPE,
@@ -134,9 +135,9 @@ class RunEvalConfig(BaseModel):
     given evaluator
     (e.g., 
     :class:`RunEvalConfig.QA <langchain.smith.evaluation.config.RunEvalConfig.QA>`)."""
-    custom_evaluators: Optional[List[CUSTOM_EVALUATOR_TYPE]] = None
+    custom_evaluators: Optional[list[CUSTOM_EVALUATOR_TYPE]] = None
     """Custom evaluators to apply to the dataset run."""
-    batch_evaluators: Optional[List[BATCH_EVALUATOR_LIKE]] = None
+    batch_evaluators: Optional[list[BATCH_EVALUATOR_LIKE]] = None
     """Evaluators that run on an aggregate/batch level.
 
     These generate 1 or more metrics that are assigned to the full test run.

langchain/smith/evaluation/progress.py

@@ -1,7 +1,8 @@
 """A simple progress bar for the console."""
 
 import threading
-from typing import Any, Dict, Optional, Sequence
+from collections.abc import Sequence
+from typing import Any, Optional
 from uuid import UUID
 
 from langchain_core.callbacks import base as base_callbacks
@@ -51,7 +52,7 @@ class ProgressBarCallback(base_callbacks.BaseCallbackHandler):
 
     def on_chain_end(
         self,
-        outputs: Dict[str, Any],
+        outputs: dict[str, Any],
         *,
         run_id: UUID,
         parent_run_id: Optional[UUID] = None,

langchain/smith/evaluation/runner_utils.py

@@ -13,10 +13,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
-    List,
     Optional,
-    Tuple,
     Union,
     cast,
 )
@@ -229,7 +226,7 @@ def _wrap_in_chain_factory(
     return llm_or_chain_factory
 
 
-def _get_prompt(inputs: Dict[str, Any]) -> str:
+def _get_prompt(inputs: dict[str, Any]) -> str:
     """Get prompt from inputs.
 
     Args:
@@ -286,10 +283,10 @@ class ChatModelInput(TypedDict):
         messages: List of chat messages.
     """
 
-    messages: List[BaseMessage]
+    messages: list[BaseMessage]
 
 
-def _get_messages(inputs: Dict[str, Any]) -> dict:
+def _get_messages(inputs: dict[str, Any]) -> dict:
     """Get Chat Messages from inputs.
 
     Args:
@@ -331,7 +328,7 @@ def _get_messages(inputs: Dict[str, Any]) -> dict:
 ## Shared data validation utilities
 def _validate_example_inputs_for_language_model(
     first_example: Example,
-    input_mapper: Optional[Callable[[Dict], Any]],
+    input_mapper: Optional[Callable[[dict], Any]],
 ) -> None:
     if input_mapper:
         prompt_input = input_mapper(first_example.inputs)
@@ -365,7 +362,7 @@ def _validate_example_inputs_for_language_model(
 def _validate_example_inputs_for_chain(
     first_example: Example,
     chain: Chain,
-    input_mapper: Optional[Callable[[Dict], Any]],
+    input_mapper: Optional[Callable[[dict], Any]],
 ) -> None:
     """Validate that the example inputs match the chain input keys."""
     if input_mapper:
@@ -402,7 +399,7 @@ def _validate_example_inputs_for_chain(
 def _validate_example_inputs(
     example: Example,
     llm_or_chain_factory: MCF,
-    input_mapper: Optional[Callable[[Dict], Any]],
+    input_mapper: Optional[Callable[[dict], Any]],
 ) -> None:
     """Validate that the example inputs are valid for the model."""
     if isinstance(llm_or_chain_factory, BaseLanguageModel):
@@ -421,10 +418,10 @@ def _validate_example_inputs(
 
 def _setup_evaluation(
     llm_or_chain_factory: MCF,
-    examples: List[Example],
+    examples: list[Example],
     evaluation: Optional[smith_eval.RunEvalConfig],
     data_type: DataType,
-) -> Optional[List[RunEvaluator]]:
+) -> Optional[list[RunEvaluator]]:
     """Configure the evaluators to run on the results of the chain."""
     if evaluation:
         if isinstance(llm_or_chain_factory, BaseLanguageModel):
@@ -451,7 +448,7 @@ def _setup_evaluation(
 
 def _determine_input_key(
     config: smith_eval.RunEvalConfig,
-    run_inputs: Optional[List[str]],
+    run_inputs: Optional[list[str]],
 ) -> Optional[str]:
     input_key = None
     if config.input_key:
@@ -475,7 +472,7 @@ def _determine_input_key(
 
 def _determine_prediction_key(
     config: smith_eval.RunEvalConfig,
-    run_outputs: Optional[List[str]],
+    run_outputs: Optional[list[str]],
 ) -> Optional[str]:
     prediction_key = None
     if config.prediction_key:
@@ -498,7 +495,7 @@ def _determine_prediction_key(
 
 def _determine_reference_key(
     config: smith_eval.RunEvalConfig,
-    example_outputs: Optional[List[str]],
+    example_outputs: Optional[list[str]],
 ) -> Optional[str]:
     if config.reference_key:
         reference_key = config.reference_key
@@ -522,7 +519,7 @@ def _construct_run_evaluator(
     eval_llm: Optional[BaseLanguageModel],
     run_type: str,
     data_type: DataType,
-    example_outputs: Optional[List[str]],
+    example_outputs: Optional[list[str]],
     reference_key: Optional[str],
     input_key: Optional[str],
     prediction_key: Optional[str],
@@ -583,10 +580,10 @@ def _construct_run_evaluator(
 
 def _get_keys(
     config: smith_eval.RunEvalConfig,
-    run_inputs: Optional[List[str]],
-    run_outputs: Optional[List[str]],
-    example_outputs: Optional[List[str]],
-) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    run_inputs: Optional[list[str]],
+    run_outputs: Optional[list[str]],
+    example_outputs: Optional[list[str]],
+) -> tuple[Optional[str], Optional[str], Optional[str]]:
     input_key = _determine_input_key(config, run_inputs)
     prediction_key = _determine_prediction_key(config, run_outputs)
     reference_key = _determine_reference_key(config, example_outputs)
@@ -597,10 +594,10 @@ def _load_run_evaluators(
     config: smith_eval.RunEvalConfig,
     run_type: str,
     data_type: DataType,
-    example_outputs: Optional[List[str]],
-    run_inputs: Optional[List[str]],
-    run_outputs: Optional[List[str]],
-) -> List[RunEvaluator]:
+    example_outputs: Optional[list[str]],
+    run_inputs: Optional[list[str]],
+    run_outputs: Optional[list[str]],
+) -> list[RunEvaluator]:
     """
     Load run evaluators from a configuration.
 
@@ -662,12 +659,12 @@ def _load_run_evaluators(
 
 async def _arun_llm(
     llm: BaseLanguageModel,
-    inputs: Dict[str, Any],
+    inputs: dict[str, Any],
     *,
-    tags: Optional[List[str]] = None,
+    tags: Optional[list[str]] = None,
     callbacks: Callbacks = None,
-    input_mapper: Optional[Callable[[Dict], Any]] = None,
-    metadata: Optional[Dict[str, Any]] = None,
+    input_mapper: Optional[Callable[[dict], Any]] = None,
+    metadata: Optional[dict[str, Any]] = None,
 ) -> Union[str, BaseMessage]:
     """Asynchronously run the language model.
 
@@ -726,12 +723,12 @@ async def _arun_llm(
 
 async def _arun_chain(
     chain: Union[Chain, Runnable],
-    inputs: Dict[str, Any],
+    inputs: dict[str, Any],
     callbacks: Callbacks,
     *,
-    tags: Optional[List[str]] = None,
-    input_mapper: Optional[Callable[[Dict], Any]] = None,
-    metadata: Optional[Dict[str, Any]] = None,
+    tags: Optional[list[str]] = None,
+    input_mapper: Optional[Callable[[dict], Any]] = None,
+    metadata: Optional[dict[str, Any]] = None,
 ) -> Union[dict, str]:
     """Run a chain asynchronously on inputs."""
     inputs_ = inputs if input_mapper is None else input_mapper(inputs)
@@ -761,7 +758,7 @@ async def _arun_llm_or_chain(
     config: RunnableConfig,
     *,
     llm_or_chain_factory: MCF,
-    input_mapper: Optional[Callable[[Dict], Any]] = None,
+    input_mapper: Optional[Callable[[dict], Any]] = None,
 ) -> Union[dict, str, LLMResult, ChatResult]:
     """Asynchronously run the Chain or language model.
 
@@ -815,12 +812,12 @@ async def _arun_llm_or_chain(
 
 def _run_llm(
     llm: BaseLanguageModel,
-    inputs: Dict[str, Any],
+    inputs: dict[str, Any],
     callbacks: Callbacks,
     *,
-    tags: Optional[List[str]] = None,
-    input_mapper: Optional[Callable[[Dict], Any]] = None,
-    metadata: Optional[Dict[str, Any]] = None,
+    tags: Optional[list[str]] = None,
+    input_mapper: Optional[Callable[[dict], Any]] = None,
+    metadata: Optional[dict[str, Any]] = None,
 ) -> Union[str, BaseMessage]:
     """
     Run the language model on the example.
@@ -877,13 +874,13 @@ def _run_llm(
 
 def _run_chain(
     chain: Union[Chain, Runnable],
-    inputs: Dict[str, Any],
+    inputs: dict[str, Any],
     callbacks: Callbacks,
     *,
-    tags: Optional[List[str]] = None,
-    input_mapper: Optional[Callable[[Dict], Any]] = None,
-    metadata: Optional[Dict[str, Any]] = None,
-) -> Union[Dict, str]:
+    tags: Optional[list[str]] = None,
+    input_mapper: Optional[Callable[[dict], Any]] = None,
+    metadata: Optional[dict[str, Any]] = None,
+) -> Union[dict, str]:
     """Run a chain on inputs."""
     inputs_ = inputs if input_mapper is None else input_mapper(inputs)
     if (
@@ -912,7 +909,7 @@ def _run_llm_or_chain(
     config: RunnableConfig,
     *,
     llm_or_chain_factory: MCF,
-    input_mapper: Optional[Callable[[Dict], Any]] = None,
+    input_mapper: Optional[Callable[[dict], Any]] = None,
 ) -> Union[dict, str, LLMResult, ChatResult]:
     """
     Run the Chain or language model synchronously.
@@ -968,10 +965,10 @@ def _prepare_eval_run(
     dataset_name: str,
     llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
     project_name: str,
-    project_metadata: Optional[Dict[str, Any]] = None,
-    tags: Optional[List[str]] = None,
+    project_metadata: Optional[dict[str, Any]] = None,
+    tags: Optional[list[str]] = None,
     dataset_version: Optional[Union[str, datetime]] = None,
-) -> Tuple[MCF, TracerSession, Dataset, List[Example]]:
+) -> tuple[MCF, TracerSession, Dataset, list[Example]]:
     wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory, dataset_name)
     dataset = client.read_dataset(dataset_name=dataset_name)
 
@@ -1027,7 +1024,7 @@ run_on_dataset(
 class _RowResult(TypedDict, total=False):
     """A dictionary of the results for a single example row."""
 
-    feedback: Optional[List[EvaluationResult]]
+    feedback: Optional[list[EvaluationResult]]
     execution_time: Optional[float]
     run_id: Optional[str]
 
@@ -1039,14 +1036,14 @@ class _DatasetRunContainer:
     client: Client
     project: TracerSession
     wrapped_model: MCF
-    examples: List[Example]
-    configs: List[RunnableConfig]
-    batch_evaluators: Optional[List[smith_eval_config.BATCH_EVALUATOR_LIKE]] = None
+    examples: list[Example]
+    configs: list[RunnableConfig]
+    batch_evaluators: Optional[list[smith_eval_config.BATCH_EVALUATOR_LIKE]] = None
 
     def _merge_test_outputs(
         self,
         batch_results: list,
-        all_eval_results: Dict[str, _RowResult],
+        all_eval_results: dict[str, _RowResult],
     ) -> dict:
         results: dict = {}
         for example, output in zip(self.examples, batch_results):
@@ -1065,7 +1062,7 @@ class _DatasetRunContainer:
                 results[str(example.id)]["reference"] = example.outputs
         return results
 
-    def _run_batch_evaluators(self, runs: Dict[str, Run]) -> List[dict]:
+    def _run_batch_evaluators(self, runs: dict[str, Run]) -> list[dict]:
         evaluators = self.batch_evaluators
         if not evaluators:
             return []
@@ -1090,7 +1087,7 @@ class _DatasetRunContainer:
                     )
         return aggregate_feedback
 
-    def _collect_metrics(self) -> Tuple[Dict[str, _RowResult], Dict[str, Run]]:
+    def _collect_metrics(self) -> tuple[dict[str, _RowResult], dict[str, Run]]:
         all_eval_results: dict = {}
         all_runs: dict = {}
         for c in self.configs:
@@ -1117,11 +1114,11 @@ class _DatasetRunContainer:
                         }
                     )
                     all_runs[str(callback.example_id)] = run
-        return cast(Dict[str, _RowResult], all_eval_results), all_runs
+        return cast(dict[str, _RowResult], all_eval_results), all_runs
 
     def _collect_test_results(
         self,
-        batch_results: List[Union[dict, str, LLMResult, ChatResult]],
+        batch_results: list[Union[dict, str, LLMResult, ChatResult]],
     ) -> TestResult:
         logger.info("Waiting for evaluators to complete.")
         wait_for_all_evaluators()
@@ -1162,10 +1159,10 @@ class _DatasetRunContainer:
         llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
         project_name: Optional[str],
         evaluation: Optional[smith_eval.RunEvalConfig] = None,
-        tags: Optional[List[str]] = None,
-        input_mapper: Optional[Callable[[Dict], Any]] = None,
+        tags: Optional[list[str]] = None,
+        input_mapper: Optional[Callable[[dict], Any]] = None,
         concurrency_level: int = 5,
-        project_metadata: Optional[Dict[str, Any]] = None,
+        project_metadata: Optional[dict[str, Any]] = None,
         revision_id: Optional[str] = None,
         dataset_version: Optional[Union[datetime, str]] = None,
     ) -> _DatasetRunContainer:
@@ -1277,11 +1274,11 @@ async def arun_on_dataset(
     dataset_version: Optional[Union[datetime, str]] = None,
     concurrency_level: int = 5,
     project_name: Optional[str] = None,
-    project_metadata: Optional[Dict[str, Any]] = None,
+    project_metadata: Optional[dict[str, Any]] = None,
     verbose: bool = False,
     revision_id: Optional[str] = None,
     **kwargs: Any,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     input_mapper = kwargs.pop("input_mapper", None)
     if input_mapper:
         warn_deprecated("0.0.305", message=_INPUT_MAPPER_DEP_WARNING, pending=True)
@@ -1342,11 +1339,11 @@ def run_on_dataset(
     dataset_version: Optional[Union[datetime, str]] = None,
     concurrency_level: int = 5,
     project_name: Optional[str] = None,
-    project_metadata: Optional[Dict[str, Any]] = None,
+    project_metadata: Optional[dict[str, Any]] = None,
     verbose: bool = False,
     revision_id: Optional[str] = None,
     **kwargs: Any,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     input_mapper = kwargs.pop("input_mapper", None)
     if input_mapper:
         warn_deprecated("0.0.305", message=_INPUT_MAPPER_DEP_WARNING, pending=True)

langchain/smith/evaluation/string_run_evaluator.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 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 +21,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 +35,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 +53,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 +66,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 +77,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 +94,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 +135,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 +146,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 +182,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 +194,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 +230,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 +239,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 +253,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 +277,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 +288,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 +304,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,7 +318,7 @@ 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]
@@ -362,7 +362,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))