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

langchain/chains/elasticsearch_database/base.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from langchain_core.callbacks import CallbackManagerForChainRun
 from langchain_core.language_models import BaseLanguageModel
@@ -44,8 +44,8 @@ class ElasticsearchDatabaseChain(Chain):
     """Elasticsearch database to connect to of type elasticsearch.Elasticsearch."""
     top_k: int = 10
     """Number of results to return from the query"""
-    ignore_indices: Optional[List[str]] = None
-    include_indices: Optional[List[str]] = None
+    ignore_indices: Optional[list[str]] = None
+    include_indices: Optional[list[str]] = None
     input_key: str = "question"  #: :meta private:
     output_key: str = "result"  #: :meta private:
     sample_documents_in_index_info: int = 3
@@ -66,7 +66,7 @@ class ElasticsearchDatabaseChain(Chain):
         return self
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the singular input key.
 
         :meta private:
@@ -74,7 +74,7 @@ class ElasticsearchDatabaseChain(Chain):
         return [self.input_key]
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Return the singular output key.
 
         :meta private:
@@ -84,7 +84,7 @@ class ElasticsearchDatabaseChain(Chain):
         else:
             return [self.output_key, INTERMEDIATE_STEPS_KEY]
 
-    def _list_indices(self) -> List[str]:
+    def _list_indices(self) -> list[str]:
         all_indices = [
             index["index"] for index in self.database.cat.indices(format="json")
         ]
@@ -96,7 +96,7 @@ class ElasticsearchDatabaseChain(Chain):
 
         return all_indices
 
-    def _get_indices_infos(self, indices: List[str]) -> str:
+    def _get_indices_infos(self, indices: list[str]) -> str:
         mappings = self.database.indices.get_mapping(index=",".join(indices))
         if self.sample_documents_in_index_info > 0:
             for k, v in mappings.items():
@@ -114,15 +114,15 @@ class ElasticsearchDatabaseChain(Chain):
             ]
         )
 
-    def _search(self, indices: List[str], query: str) -> str:
+    def _search(self, indices: list[str], query: str) -> str:
         result = self.database.search(index=",".join(indices), body=query)
         return str(result)
 
     def _call(
         self,
-        inputs: Dict[str, Any],
+        inputs: dict[str, Any],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         input_text = f"{inputs[self.input_key]}\nESQuery:"
         _run_manager.on_text(input_text, verbose=self.verbose)
@@ -134,7 +134,7 @@ class ElasticsearchDatabaseChain(Chain):
             "indices_info": indices_info,
             "stop": ["\nESResult:"],
         }
-        intermediate_steps: List = []
+        intermediate_steps: list = []
         try:
             intermediate_steps.append(query_inputs)  # input: es generation
             es_cmd = self.query_chain.invoke(
@@ -163,14 +163,14 @@ class ElasticsearchDatabaseChain(Chain):
 
             intermediate_steps.append(final_result)  # output: final answer
             _run_manager.on_text(final_result, color="green", verbose=self.verbose)
-            chain_result: Dict[str, Any] = {self.output_key: final_result}
+            chain_result: dict[str, Any] = {self.output_key: final_result}
             if self.return_intermediate_steps:
                 chain_result[INTERMEDIATE_STEPS_KEY] = intermediate_steps
             return chain_result
         except Exception as exc:
             # Append intermediate steps to exception, to aid in logging and later
             # improvement of few shot prompt seeds
-            exc.intermediate_steps = intermediate_steps  # type: ignore
+            exc.intermediate_steps = intermediate_steps  # type: ignore[attr-defined]
             raise exc
 
     @property

langchain/chains/example_generator.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.prompts.few_shot import FewShotPromptTemplate
@@ -9,7 +7,7 @@ TEST_GEN_TEMPLATE_SUFFIX = "Add another example."
 
 
 def generate_example(
-    examples: List[dict], llm: BaseLanguageModel, prompt_template: PromptTemplate
+    examples: list[dict], llm: BaseLanguageModel, prompt_template: PromptTemplate
 ) -> str:
     """Return another example given a list of examples for a prompt."""
     prompt = FewShotPromptTemplate(

langchain/chains/flare/base.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import logging
 import re
-from typing import Any, Dict, List, Optional, Sequence, Tuple
+from collections.abc import Sequence
+from typing import Any, Optional
 
 from langchain_core.callbacks import (
     CallbackManagerForChainRun,
@@ -26,7 +27,7 @@ from langchain.chains.llm import LLMChain
 logger = logging.getLogger(__name__)
 
 
-def _extract_tokens_and_log_probs(response: AIMessage) -> Tuple[List[str], List[float]]:
+def _extract_tokens_and_log_probs(response: AIMessage) -> tuple[list[str], list[float]]:
     """Extract tokens and log probabilities from chat model response."""
     tokens = []
     log_probs = []
@@ -47,7 +48,7 @@ class QuestionGeneratorChain(LLMChain):
         return False
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Input keys for the chain."""
         return ["user_input", "context", "response"]
 
@@ -58,7 +59,7 @@ def _low_confidence_spans(
     min_prob: float,
     min_token_gap: int,
     num_pad_tokens: int,
-) -> List[str]:
+) -> list[str]:
     try:
         import numpy as np
 
@@ -117,22 +118,22 @@ class FlareChain(Chain):
     """Whether to start with retrieval."""
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Input keys for the chain."""
         return ["user_input"]
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Output keys for the chain."""
         return ["response"]
 
     def _do_generation(
         self,
-        questions: List[str],
+        questions: list[str],
         user_input: str,
         response: str,
         _run_manager: CallbackManagerForChainRun,
-    ) -> Tuple[str, bool]:
+    ) -> tuple[str, bool]:
         callbacks = _run_manager.get_child()
         docs = []
         for question in questions:
@@ -153,12 +154,12 @@ class FlareChain(Chain):
 
     def _do_retrieval(
         self,
-        low_confidence_spans: List[str],
+        low_confidence_spans: list[str],
         _run_manager: CallbackManagerForChainRun,
         user_input: str,
         response: str,
         initial_response: str,
-    ) -> Tuple[str, bool]:
+    ) -> tuple[str, bool]:
         question_gen_inputs = [
             {
                 "user_input": user_input,
@@ -187,9 +188,9 @@ class FlareChain(Chain):
 
     def _call(
         self,
-        inputs: Dict[str, Any],
+        inputs: dict[str, Any],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
 
         user_input = inputs[self.input_keys[0]]

langchain/chains/flare/prompts.py

@@ -1,16 +1,14 @@
-from typing import Tuple
-
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.prompts import PromptTemplate
 
 
-class FinishedOutputParser(BaseOutputParser[Tuple[str, bool]]):
+class FinishedOutputParser(BaseOutputParser[tuple[str, bool]]):
     """Output parser that checks if the output is finished."""
 
     finished_value: str = "FINISHED"
     """Value that indicates the output is finished."""
 
-    def parse(self, text: str) -> Tuple[str, bool]:
+    def parse(self, text: str) -> tuple[str, bool]:
         cleaned = text.strip()
         finished = self.finished_value in cleaned
         return cleaned.replace(self.finished_value, ""), finished

langchain/chains/hyde/base.py

@@ -6,7 +6,7 @@ https://arxiv.org/abs/2212.10496
 from __future__ import annotations
 
 import logging
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from langchain_core.callbacks import CallbackManagerForChainRun
 from langchain_core.embeddings import Embeddings
@@ -38,23 +38,23 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
     )
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Input keys for Hyde's LLM chain."""
         return self.llm_chain.input_schema.model_json_schema()["required"]
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Output keys for Hyde's LLM chain."""
         if isinstance(self.llm_chain, LLMChain):
             return self.llm_chain.output_keys
         else:
             return ["text"]
 
-    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+    def embed_documents(self, texts: list[str]) -> list[list[float]]:
         """Call the base embeddings."""
         return self.base_embeddings.embed_documents(texts)
 
-    def combine_embeddings(self, embeddings: List[List[float]]) -> List[float]:
+    def combine_embeddings(self, embeddings: list[list[float]]) -> list[float]:
         """Combine embeddings into final embeddings."""
         try:
             import numpy as np
@@ -73,7 +73,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
             num_vectors = len(embeddings)
             return [sum(dim_values) / num_vectors for dim_values in zip(*embeddings)]
 
-    def embed_query(self, text: str) -> List[float]:
+    def embed_query(self, text: str) -> list[float]:
         """Generate a hypothetical document and embedded it."""
         var_name = self.input_keys[0]
         result = self.llm_chain.invoke({var_name: text})
@@ -86,9 +86,9 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
 
     def _call(
         self,
-        inputs: Dict[str, Any],
+        inputs: dict[str, Any],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         """Call the internal llm chain."""
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         return self.llm_chain.invoke(

langchain/chains/llm.py

@@ -3,7 +3,8 @@
 from __future__ import annotations
 
 import warnings
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union, cast
+from collections.abc import Sequence
+from typing import Any, Optional, Union, cast
 
 from langchain_core._api import deprecated
 from langchain_core.callbacks import (
@@ -100,7 +101,7 @@ class LLMChain(Chain):
     )
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Will be whatever keys the prompt expects.
 
         :meta private:
@@ -108,7 +109,7 @@ class LLMChain(Chain):
         return self.prompt.input_variables
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Will always return text key.
 
         :meta private:
@@ -120,15 +121,15 @@ class LLMChain(Chain):
 
     def _call(
         self,
-        inputs: Dict[str, Any],
+        inputs: dict[str, Any],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         response = self.generate([inputs], run_manager=run_manager)
         return self.create_outputs(response)[0]
 
     def generate(
         self,
-        input_list: List[Dict[str, Any]],
+        input_list: list[dict[str, Any]],
         run_manager: Optional[CallbackManagerForChainRun] = None,
     ) -> LLMResult:
         """Generate LLM result from inputs."""
@@ -143,9 +144,9 @@ class LLMChain(Chain):
             )
         else:
             results = self.llm.bind(stop=stop, **self.llm_kwargs).batch(
-                cast(List, prompts), {"callbacks": callbacks}
+                cast(list, prompts), {"callbacks": callbacks}
             )
-            generations: List[List[Generation]] = []
+            generations: list[list[Generation]] = []
             for res in results:
                 if isinstance(res, BaseMessage):
                     generations.append([ChatGeneration(message=res)])
@@ -155,7 +156,7 @@ class LLMChain(Chain):
 
     async def agenerate(
         self,
-        input_list: List[Dict[str, Any]],
+        input_list: list[dict[str, Any]],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
     ) -> LLMResult:
         """Generate LLM result from inputs."""
@@ -170,9 +171,9 @@ class LLMChain(Chain):
             )
         else:
             results = await self.llm.bind(stop=stop, **self.llm_kwargs).abatch(
-                cast(List, prompts), {"callbacks": callbacks}
+                cast(list, prompts), {"callbacks": callbacks}
             )
-            generations: List[List[Generation]] = []
+            generations: list[list[Generation]] = []
             for res in results:
                 if isinstance(res, BaseMessage):
                     generations.append([ChatGeneration(message=res)])
@@ -182,9 +183,9 @@ class LLMChain(Chain):
 
     def prep_prompts(
         self,
-        input_list: List[Dict[str, Any]],
+        input_list: list[dict[str, Any]],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Tuple[List[PromptValue], Optional[List[str]]]:
+    ) -> tuple[list[PromptValue], Optional[list[str]]]:
         """Prepare prompts from inputs."""
         stop = None
         if len(input_list) == 0:
@@ -208,9 +209,9 @@ class LLMChain(Chain):
 
     async def aprep_prompts(
         self,
-        input_list: List[Dict[str, Any]],
+        input_list: list[dict[str, Any]],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> Tuple[List[PromptValue], Optional[List[str]]]:
+    ) -> tuple[list[PromptValue], Optional[list[str]]]:
         """Prepare prompts from inputs."""
         stop = None
         if len(input_list) == 0:
@@ -233,8 +234,8 @@ class LLMChain(Chain):
         return prompts, stop
 
     def apply(
-        self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
-    ) -> List[Dict[str, str]]:
+        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+    ) -> list[dict[str, str]]:
         """Utilize the LLM generate method for speed gains."""
         callback_manager = CallbackManager.configure(
             callbacks, self.callbacks, self.verbose
@@ -254,8 +255,8 @@ class LLMChain(Chain):
         return outputs
 
     async def aapply(
-        self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
-    ) -> List[Dict[str, str]]:
+        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+    ) -> list[dict[str, str]]:
         """Utilize the LLM generate method for speed gains."""
         callback_manager = AsyncCallbackManager.configure(
             callbacks, self.callbacks, self.verbose
@@ -278,7 +279,7 @@ class LLMChain(Chain):
     def _run_output_key(self) -> str:
         return self.output_key
 
-    def create_outputs(self, llm_result: LLMResult) -> List[Dict[str, Any]]:
+    def create_outputs(self, llm_result: LLMResult) -> list[dict[str, Any]]:
         """Create outputs from response."""
         result = [
             # Get the text of the top generated string.
@@ -294,9 +295,9 @@ class LLMChain(Chain):
 
     async def _acall(
         self,
-        inputs: Dict[str, Any],
+        inputs: dict[str, Any],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         response = await self.agenerate([inputs], run_manager=run_manager)
         return self.create_outputs(response)[0]
 
@@ -336,7 +337,7 @@ class LLMChain(Chain):
 
     def predict_and_parse(
         self, callbacks: Callbacks = None, **kwargs: Any
-    ) -> Union[str, List[str], Dict[str, Any]]:
+    ) -> Union[str, list[str], dict[str, Any]]:
         """Call predict and then parse the results."""
         warnings.warn(
             "The predict_and_parse method is deprecated, "
@@ -350,7 +351,7 @@ class LLMChain(Chain):
 
     async def apredict_and_parse(
         self, callbacks: Callbacks = None, **kwargs: Any
-    ) -> Union[str, List[str], Dict[str, str]]:
+    ) -> Union[str, list[str], dict[str, str]]:
         """Call apredict and then parse the results."""
         warnings.warn(
             "The apredict_and_parse method is deprecated, "
@@ -363,8 +364,8 @@ class LLMChain(Chain):
             return result
 
     def apply_and_parse(
-        self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
-    ) -> Sequence[Union[str, List[str], Dict[str, str]]]:
+        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+    ) -> Sequence[Union[str, list[str], dict[str, str]]]:
         """Call apply and then parse the results."""
         warnings.warn(
             "The apply_and_parse method is deprecated, "
@@ -374,8 +375,8 @@ class LLMChain(Chain):
         return self._parse_generation(result)
 
     def _parse_generation(
-        self, generation: List[Dict[str, str]]
-    ) -> Sequence[Union[str, List[str], Dict[str, str]]]:
+        self, generation: list[dict[str, str]]
+    ) -> Sequence[Union[str, list[str], dict[str, str]]]:
         if self.prompt.output_parser is not None:
             return [
                 self.prompt.output_parser.parse(res[self.output_key])
@@ -385,8 +386,8 @@ class LLMChain(Chain):
             return generation
 
     async def aapply_and_parse(
-        self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
-    ) -> Sequence[Union[str, List[str], Dict[str, str]]]:
+        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+    ) -> Sequence[Union[str, list[str], dict[str, str]]]:
         """Call apply and then parse the results."""
         warnings.warn(
             "The aapply_and_parse method is deprecated, "

langchain/chains/llm_checker/base.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import warnings
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from langchain_core._api import deprecated
 from langchain_core.callbacks import CallbackManagerForChainRun
@@ -107,7 +107,7 @@ class LLMCheckerChain(Chain):
 
     @model_validator(mode="before")
     @classmethod
-    def raise_deprecation(cls, values: Dict) -> Any:
+    def raise_deprecation(cls, values: dict) -> Any:
         if "llm" in values:
             warnings.warn(
                 "Directly instantiating an LLMCheckerChain with an llm is deprecated. "
@@ -135,7 +135,7 @@ class LLMCheckerChain(Chain):
         return values
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the singular input key.
 
         :meta private:
@@ -143,7 +143,7 @@ class LLMCheckerChain(Chain):
         return [self.input_key]
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Return the singular output key.
 
         :meta private:
@@ -152,9 +152,9 @@ class LLMCheckerChain(Chain):
 
     def _call(
         self,
-        inputs: Dict[str, Any],
+        inputs: dict[str, Any],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         question = inputs[self.input_key]
 

langchain/chains/llm_math/base.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import math
 import re
 import warnings
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from langchain_core._api import deprecated
 from langchain_core.callbacks import (
@@ -163,7 +163,7 @@ class LLMMathChain(Chain):
 
     @model_validator(mode="before")
     @classmethod
-    def raise_deprecation(cls, values: Dict) -> Any:
+    def raise_deprecation(cls, values: dict) -> Any:
         try:
             import numexpr  # noqa: F401
         except ImportError:
@@ -183,7 +183,7 @@ class LLMMathChain(Chain):
         return values
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Expect input key.
 
         :meta private:
@@ -191,7 +191,7 @@ class LLMMathChain(Chain):
         return [self.input_key]
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Expect output key.
 
         :meta private:
@@ -221,7 +221,7 @@ class LLMMathChain(Chain):
 
     def _process_llm_result(
         self, llm_output: str, run_manager: CallbackManagerForChainRun
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         run_manager.on_text(llm_output, color="green", verbose=self.verbose)
         llm_output = llm_output.strip()
         text_match = re.search(r"^```text(.*?)```", llm_output, re.DOTALL)
@@ -243,7 +243,7 @@ class LLMMathChain(Chain):
         self,
         llm_output: str,
         run_manager: AsyncCallbackManagerForChainRun,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         await run_manager.on_text(llm_output, color="green", verbose=self.verbose)
         llm_output = llm_output.strip()
         text_match = re.search(r"^```text(.*?)```", llm_output, re.DOTALL)
@@ -263,9 +263,9 @@ class LLMMathChain(Chain):
 
     def _call(
         self,
-        inputs: Dict[str, str],
+        inputs: dict[str, str],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         _run_manager.on_text(inputs[self.input_key])
         llm_output = self.llm_chain.predict(
@@ -277,9 +277,9 @@ class LLMMathChain(Chain):
 
     async def _acall(
         self,
-        inputs: Dict[str, str],
+        inputs: dict[str, str],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
         await _run_manager.on_text(inputs[self.input_key])
         llm_output = await self.llm_chain.apredict(

langchain/chains/llm_summarization_checker/base.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import warnings
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from langchain_core._api import deprecated
 from langchain_core.callbacks import CallbackManagerForChainRun
@@ -112,7 +112,7 @@ class LLMSummarizationCheckerChain(Chain):
 
     @model_validator(mode="before")
     @classmethod
-    def raise_deprecation(cls, values: Dict) -> Any:
+    def raise_deprecation(cls, values: dict) -> Any:
         if "llm" in values:
             warnings.warn(
                 "Directly instantiating an LLMSummarizationCheckerChain with an llm is "
@@ -131,7 +131,7 @@ class LLMSummarizationCheckerChain(Chain):
         return values
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the singular input key.
 
         :meta private:
@@ -139,7 +139,7 @@ class LLMSummarizationCheckerChain(Chain):
         return [self.input_key]
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Return the singular output key.
 
         :meta private:
@@ -148,9 +148,9 @@ class LLMSummarizationCheckerChain(Chain):
 
     def _call(
         self,
-        inputs: Dict[str, Any],
+        inputs: dict[str, Any],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         all_true = False
         count = 0