langchain 0.3.26__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

langchain/document_transformers/nuclia_text_transform.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
 # Used to consolidate logic for raising deprecation warnings and
 # handling optional imports.
 DEPRECATED_LOOKUP = {
-    "NucliaTextTransformer": "langchain_community.document_transformers"
+    "NucliaTextTransformer": "langchain_community.document_transformers",
 }
 
 _import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)

langchain/embeddings/__init__.py

@@ -1,7 +1,7 @@
 """**Embedding models**  are wrappers around embedding models
 from different APIs and services.
 
-**Embedding models** can be LLMs or not.
+Embedding models can be LLMs or not.
 
 **Class hierarchy:**
 
@@ -83,17 +83,17 @@ class HypotheticalDocumentEmbedder:
     def __init__(self, *args: Any, **kwargs: Any):
         logger.warning(
             "Using a deprecated class. Please use "
-            "`from langchain.chains import HypotheticalDocumentEmbedder` instead"
+            "`from langchain.chains import HypotheticalDocumentEmbedder` instead",
         )
         from langchain.chains.hyde.base import HypotheticalDocumentEmbedder as H
 
-        return H(*args, **kwargs)  # type: ignore[return-value]
+        return H(*args, **kwargs)  # type: ignore[return-value] # noqa: PLE0101
 
     @classmethod
     def from_llm(cls, *args: Any, **kwargs: Any) -> Any:
         logger.warning(
             "Using a deprecated class. Please use "
-            "`from langchain.chains import HypotheticalDocumentEmbedder` instead"
+            "`from langchain.chains import HypotheticalDocumentEmbedder` instead",
         )
         from langchain.chains.hyde.base import HypotheticalDocumentEmbedder as H
 
@@ -187,8 +187,8 @@ __all__ = [
     "ErnieEmbeddings",
     "FakeEmbeddings",
     "FastEmbedEmbeddings",
-    "GooglePalmEmbeddings",
     "GPT4AllEmbeddings",
+    "GooglePalmEmbeddings",
     "GradientEmbeddings",
     "HuggingFaceBgeEmbeddings",
     "HuggingFaceEmbeddings",

langchain/embeddings/base.py

@@ -47,10 +47,11 @@ def _parse_model_string(model_name: str) -> tuple[str, str]:
     Raises:
         ValueError: If the model string is not in the correct format or
             the provider is unsupported
+
     """
     if ":" not in model_name:
         providers = _SUPPORTED_PROVIDERS
-        raise ValueError(
+        msg = (
             f"Invalid model format '{model_name}'.\n"
             f"Model name must be in format 'provider:model-name'\n"
             f"Example valid model strings:\n"
@@ -59,49 +60,56 @@ def _parse_model_string(model_name: str) -> tuple[str, str]:
             f"  - cohere:embed-english-v3.0\n"
             f"Supported providers: {providers}"
         )
+        raise ValueError(msg)
 
     provider, model = model_name.split(":", 1)
     provider = provider.lower().strip()
     model = model.strip()
 
     if provider not in _SUPPORTED_PROVIDERS:
-        raise ValueError(
+        msg = (
             f"Provider '{provider}' is not supported.\n"
             f"Supported providers and their required packages:\n"
             f"{_get_provider_list()}"
         )
+        raise ValueError(msg)
     if not model:
-        raise ValueError("Model name cannot be empty")
+        msg = "Model name cannot be empty"
+        raise ValueError(msg)
     return provider, model
 
 
 def _infer_model_and_provider(
-    model: str, *, provider: Optional[str] = None
+    model: str,
+    *,
+    provider: Optional[str] = None,
 ) -> tuple[str, str]:
     if not model.strip():
-        raise ValueError("Model name cannot be empty")
+        msg = "Model name cannot be empty"
+        raise ValueError(msg)
     if provider is None and ":" in model:
         provider, model_name = _parse_model_string(model)
     else:
-        provider = provider
         model_name = model
 
     if not provider:
         providers = _SUPPORTED_PROVIDERS
-        raise ValueError(
+        msg = (
             "Must specify either:\n"
             "1. A model string in format 'provider:model-name'\n"
             "   Example: 'openai:text-embedding-3-small'\n"
             "2. Or explicitly set provider from: "
             f"{providers}"
         )
+        raise ValueError(msg)
 
     if provider not in _SUPPORTED_PROVIDERS:
-        raise ValueError(
+        msg = (
             f"Provider '{provider}' is not supported.\n"
             f"Supported providers and their required packages:\n"
             f"{_get_provider_list()}"
         )
+        raise ValueError(msg)
     return provider, model_name
 
 
@@ -109,10 +117,11 @@ def _infer_model_and_provider(
 def _check_pkg(pkg: str) -> None:
     """Check if a package is installed."""
     if not util.find_spec(pkg):
-        raise ImportError(
+        msg = (
             f"Could not import {pkg} python package. "
             f"Please install it with `pip install {pkg}`"
         )
+        raise ImportError(msg)
 
 
 def init_embeddings(
@@ -169,12 +178,14 @@ def init_embeddings(
             )
 
     .. versionadded:: 0.3.9
+
     """
     if not model:
         providers = _SUPPORTED_PROVIDERS.keys()
-        raise ValueError(
+        msg = (
             f"Must specify model name. Supported providers are: {', '.join(providers)}"
         )
+        raise ValueError(msg)
 
     provider, model_name = _infer_model_and_provider(model, provider=provider)
     pkg = _SUPPORTED_PROVIDERS[provider]
@@ -184,43 +195,43 @@ def init_embeddings(
         from langchain_openai import OpenAIEmbeddings
 
         return OpenAIEmbeddings(model=model_name, **kwargs)
-    elif provider == "azure_openai":
+    if provider == "azure_openai":
         from langchain_openai import AzureOpenAIEmbeddings
 
         return AzureOpenAIEmbeddings(model=model_name, **kwargs)
-    elif provider == "google_vertexai":
+    if provider == "google_vertexai":
         from langchain_google_vertexai import VertexAIEmbeddings
 
         return VertexAIEmbeddings(model=model_name, **kwargs)
-    elif provider == "bedrock":
+    if provider == "bedrock":
         from langchain_aws import BedrockEmbeddings
 
         return BedrockEmbeddings(model_id=model_name, **kwargs)
-    elif provider == "cohere":
+    if provider == "cohere":
         from langchain_cohere import CohereEmbeddings
 
         return CohereEmbeddings(model=model_name, **kwargs)
-    elif provider == "mistralai":
+    if provider == "mistralai":
         from langchain_mistralai import MistralAIEmbeddings
 
         return MistralAIEmbeddings(model=model_name, **kwargs)
-    elif provider == "huggingface":
+    if provider == "huggingface":
         from langchain_huggingface import HuggingFaceEmbeddings
 
         return HuggingFaceEmbeddings(model_name=model_name, **kwargs)
-    elif provider == "ollama":
+    if provider == "ollama":
         from langchain_ollama import OllamaEmbeddings
 
         return OllamaEmbeddings(model=model_name, **kwargs)
-    else:
-        raise ValueError(
-            f"Provider '{provider}' is not supported.\n"
-            f"Supported providers and their required packages:\n"
-            f"{_get_provider_list()}"
-        )
+    msg = (
+        f"Provider '{provider}' is not supported.\n"
+        f"Supported providers and their required packages:\n"
+        f"{_get_provider_list()}"
+    )
+    raise ValueError(msg)
 
 
 __all__ = [
-    "init_embeddings",
     "Embeddings",  # This one is for backwards compatibility
+    "init_embeddings",
 ]

langchain/embeddings/cache.py

@@ -26,16 +26,16 @@ NAMESPACE_UUID = uuid.UUID(int=1985)
 
 
 def _sha1_hash_to_uuid(text: str) -> uuid.UUID:
-    """Return a UUID derived from *text* using SHA‑1 (deterministic).
+    """Return a UUID derived from *text* using SHA-1 (deterministic).
 
-    Deterministic and fast, **but not collision‑resistant**.
+    Deterministic and fast, **but not collision-resistant**.
 
     A malicious attacker could try to create two different texts that hash to the same
     UUID. This may not necessarily be an issue in the context of caching embeddings,
     but new applications should swap this out for a stronger hash function like
-    xxHash, BLAKE2 or SHA‑256, which are collision-resistant.
+    xxHash, BLAKE2 or SHA-256, which are collision-resistant.
     """
-    sha1_hex = hashlib.sha1(text.encode("utf-8")).hexdigest()
+    sha1_hex = hashlib.sha1(text.encode("utf-8"), usedforsecurity=False).hexdigest()
     # Embed the hex string in `uuid5` to obtain a valid UUID.
     return uuid.uuid5(NAMESPACE_UUID, sha1_hex)
 
@@ -44,12 +44,12 @@ def _make_default_key_encoder(namespace: str, algorithm: str) -> Callable[[str],
     """Create a default key encoder function.
 
     Args:
-       namespace: Prefix that segregates keys from different embedding models.
-       algorithm:
-           * `sha1` - fast but not collision‑resistant
-           * `blake2b` - cryptographically strong, faster than SHA‑1
-           * `sha256` - cryptographically strong, slower than SHA‑1
-           * `sha512` - cryptographically strong, slower than SHA‑1
+        namespace: Prefix that segregates keys from different embedding models.
+        algorithm:
+           * ``'sha1'`` - fast but not collision-resistant
+           * ``'blake2b'`` - cryptographically strong, faster than SHA-1
+           * ``'sha256'`` - cryptographically strong, slower than SHA-1
+           * ``'sha512'`` - cryptographically strong, slower than SHA-1
 
     Returns:
         A function that encodes a key using the specified algorithm.
@@ -67,7 +67,8 @@ def _make_default_key_encoder(namespace: str, algorithm: str) -> Callable[[str],
             return f"{namespace}{hashlib.sha256(key.encode('utf-8')).hexdigest()}"
         if algorithm == "sha512":
             return f"{namespace}{hashlib.sha512(key.encode('utf-8')).hexdigest()}"
-        raise ValueError(f"Unsupported algorithm: {algorithm}")
+        msg = f"Unsupported algorithm: {algorithm}"
+        raise ValueError(msg)
 
     return _key_encoder
 
@@ -79,7 +80,7 @@ def _value_serializer(value: Sequence[float]) -> bytes:
 
 def _value_deserializer(serialized_value: bytes) -> list[float]:
     """Deserialize a value."""
-    return cast(list[float], json.loads(serialized_value.decode()))
+    return cast("list[float]", json.loads(serialized_value.decode()))
 
 
 # The warning is global; track emission, so it appears only once.
@@ -87,15 +88,15 @@ _warned_about_sha1: bool = False
 
 
 def _warn_about_sha1_encoder() -> None:
-    """Emit a one‑time warning about SHA‑1 collision weaknesses."""
-    global _warned_about_sha1
+    """Emit a one-time warning about SHA-1 collision weaknesses."""
+    global _warned_about_sha1  # noqa: PLW0603
     if not _warned_about_sha1:
         warnings.warn(
-            "Using default key encoder: SHA‑1 is *not* collision‑resistant. "
+            "Using default key encoder: SHA-1 is *not* collision-resistant. "
             "While acceptable for most cache scenarios, a motivated attacker "
             "can craft two different payloads that map to the same cache key. "
             "If that risk matters in your environment, supply a stronger "
-            "encoder (e.g. SHA‑256 or BLAKE2) via the `key_encoder` argument. "
+            "encoder (e.g. SHA-256 or BLAKE2) via the `key_encoder` argument. "
             "If you change the key encoder, consider also creating a new cache, "
             "to avoid (the potential for) collisions with existing keys.",
             category=UserWarning,
@@ -118,7 +119,6 @@ class CacheBackedEmbeddings(Embeddings):
     embeddings too, pass in a query_embedding_store to constructor.
 
     Examples:
-
         .. code-block: python
 
             from langchain.embeddings import CacheBackedEmbeddings
@@ -154,7 +154,7 @@ class CacheBackedEmbeddings(Embeddings):
             document_embedding_store: The store to use for caching document embeddings.
             batch_size: The number of documents to embed between store updates.
             query_embedding_store: The store to use for caching query embeddings.
-                If None, query embeddings are not cached.
+                If ``None``, query embeddings are not cached.
         """
         super().__init__()
         self.document_embedding_store = document_embedding_store
@@ -176,7 +176,7 @@ class CacheBackedEmbeddings(Embeddings):
             A list of embeddings for the given texts.
         """
         vectors: list[Union[list[float], None]] = self.document_embedding_store.mget(
-            texts
+            texts,
         )
         all_missing_indices: list[int] = [
             i for i, vector in enumerate(vectors) if vector is None
@@ -186,13 +186,14 @@ class CacheBackedEmbeddings(Embeddings):
             missing_texts = [texts[i] for i in missing_indices]
             missing_vectors = self.underlying_embeddings.embed_documents(missing_texts)
             self.document_embedding_store.mset(
-                list(zip(missing_texts, missing_vectors))
+                list(zip(missing_texts, missing_vectors)),
             )
             for index, updated_vector in zip(missing_indices, missing_vectors):
                 vectors[index] = updated_vector
 
         return cast(
-            list[list[float]], vectors
+            "list[list[float]]",
+            vectors,
         )  # Nones should have been resolved by now
 
     async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
@@ -220,23 +221,24 @@ class CacheBackedEmbeddings(Embeddings):
         for missing_indices in batch_iterate(self.batch_size, all_missing_indices):
             missing_texts = [texts[i] for i in missing_indices]
             missing_vectors = await self.underlying_embeddings.aembed_documents(
-                missing_texts
+                missing_texts,
             )
             await self.document_embedding_store.amset(
-                list(zip(missing_texts, missing_vectors))
+                list(zip(missing_texts, missing_vectors)),
             )
             for index, updated_vector in zip(missing_indices, missing_vectors):
                 vectors[index] = updated_vector
 
         return cast(
-            list[list[float]], vectors
+            "list[list[float]]",
+            vectors,
         )  # Nones should have been resolved by now
 
     def embed_query(self, text: str) -> list[float]:
         """Embed query text.
 
         By default, this method does not cache queries. To enable caching, set the
-        `cache_query` parameter to `True` when initializing the embedder.
+        ``cache_query`` parameter to ``True`` when initializing the embedder.
 
         Args:
             text: The text to embed.
@@ -259,7 +261,7 @@ class CacheBackedEmbeddings(Embeddings):
         """Embed query text.
 
         By default, this method does not cache queries. To enable caching, set the
-        `cache_query` parameter to `True` when initializing the embedder.
+        ``cache_query`` parameter to ``True`` when initializing the embedder.
 
         Args:
             text: The text to embed.
@@ -288,7 +290,8 @@ class CacheBackedEmbeddings(Embeddings):
         batch_size: Optional[int] = None,
         query_embedding_cache: Union[bool, ByteStore] = False,
         key_encoder: Union[
-            Callable[[str], str], Literal["sha1", "blake2b", "sha256", "sha512"]
+            Callable[[str], str],
+            Literal["sha1", "blake2b", "sha256", "sha512"],
         ] = "sha1",
     ) -> CacheBackedEmbeddings:
         """On-ramp that adds the necessary serialization and encoding to the store.
@@ -298,14 +301,14 @@ class CacheBackedEmbeddings(Embeddings):
             document_embedding_cache: The cache to use for storing document embeddings.
             *,
             namespace: The namespace to use for document cache.
-                       This namespace is used to avoid collisions with other caches.
-                       For example, set it to the name of the embedding model used.
+                This namespace is used to avoid collisions with other caches.
+                For example, set it to the name of the embedding model used.
             batch_size: The number of documents to embed between store updates.
             query_embedding_cache: The cache to use for storing query embeddings.
                 True to use the same cache as document embeddings.
                 False to not cache query embeddings.
             key_encoder: Optional callable to encode keys. If not provided,
-                a default encoder using SHA‑1 will be used. SHA-1 is not
+                a default encoder using SHA-1 will be used. SHA-1 is not
                 collision-resistant, and a motivated attacker could craft two
                 different texts that hash to the same cache key.
 
@@ -327,15 +330,17 @@ class CacheBackedEmbeddings(Embeddings):
             # namespace.
             # A user can handle namespacing in directly their custom key encoder.
             if namespace:
-                raise ValueError(
+                msg = (
                     "Do not supply `namespace` when using a custom key_encoder; "
                     "add any prefixing inside the encoder itself."
                 )
+                raise ValueError(msg)
         else:
-            raise ValueError(
+            msg = (
                 "key_encoder must be either 'blake2b', 'sha1', 'sha256', 'sha512' "
                 "or a callable that encodes keys."
             )
+            raise ValueError(msg)  # noqa: TRY004
 
         document_embedding_store = EncoderBackedStore[str, list[float]](
             document_embedding_cache,

langchain/embeddings/fake.py

@@ -25,6 +25,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "FakeEmbeddings",
     "DeterministicFakeEmbedding",
+    "FakeEmbeddings",
 ]

langchain/embeddings/huggingface.py

@@ -29,8 +29,8 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "HuggingFaceEmbeddings",
-    "HuggingFaceInstructEmbeddings",
     "HuggingFaceBgeEmbeddings",
+    "HuggingFaceEmbeddings",
     "HuggingFaceInferenceAPIEmbeddings",
+    "HuggingFaceInstructEmbeddings",
 ]

langchain/evaluation/__init__.py

@@ -95,34 +95,34 @@ from langchain.evaluation.string_distance import (
 )
 
 __all__ = [
-    "EvaluatorType",
-    "ExactMatchStringEvaluator",
-    "RegexMatchStringEvaluator",
-    "PairwiseStringEvalChain",
-    "LabeledPairwiseStringEvalChain",
-    "QAEvalChain",
-    "CotQAEvalChain",
+    "AgentTrajectoryEvaluator",
     "ContextQAEvalChain",
-    "StringEvaluator",
-    "PairwiseStringEvaluator",
-    "TrajectoryEvalChain",
-    "CriteriaEvalChain",
+    "CotQAEvalChain",
     "Criteria",
+    "CriteriaEvalChain",
     "EmbeddingDistance",
     "EmbeddingDistanceEvalChain",
+    "EvaluatorType",
+    "ExactMatchStringEvaluator",
+    "JsonEditDistanceEvaluator",
+    "JsonEqualityEvaluator",
+    "JsonSchemaEvaluator",
+    "JsonValidityEvaluator",
+    "LabeledCriteriaEvalChain",
+    "LabeledPairwiseStringEvalChain",
+    "LabeledScoreStringEvalChain",
     "PairwiseEmbeddingDistanceEvalChain",
+    "PairwiseStringDistanceEvalChain",
+    "PairwiseStringEvalChain",
+    "PairwiseStringEvaluator",
+    "QAEvalChain",
+    "RegexMatchStringEvaluator",
+    "ScoreStringEvalChain",
     "StringDistance",
     "StringDistanceEvalChain",
-    "PairwiseStringDistanceEvalChain",
-    "LabeledCriteriaEvalChain",
-    "load_evaluators",
-    "load_evaluator",
+    "StringEvaluator",
+    "TrajectoryEvalChain",
     "load_dataset",
-    "AgentTrajectoryEvaluator",
-    "ScoreStringEvalChain",
-    "LabeledScoreStringEvalChain",
-    "JsonValidityEvaluator",
-    "JsonEqualityEvaluator",
-    "JsonEditDistanceEvaluator",
-    "JsonSchemaEvaluator",
+    "load_evaluator",
+    "load_evaluators",
 ]

langchain/evaluation/agents/trajectory_eval_chain.py

@@ -27,6 +27,7 @@ from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.tools import BaseTool
 from pydantic import ConfigDict, Field
+from typing_extensions import override
 
 from langchain.chains.llm import LLMChain
 from langchain.evaluation.agents.trajectory_eval_prompt import (
@@ -35,6 +36,8 @@ from langchain.evaluation.agents.trajectory_eval_prompt import (
 )
 from langchain.evaluation.schema import AgentTrajectoryEvaluator, LLMEvalChain
 
+_MAX_SCORE = 5
+
 
 class TrajectoryEval(TypedDict):
     """A named tuple containing the score and reasoning for a trajectory."""
@@ -66,9 +69,8 @@ class TrajectoryOutputParser(BaseOutputParser):
                 if the LLM's score is not a digit in the range 1-5.
         """
         if "Score:" not in text:
-            raise OutputParserException(
-                f"Could not find score in model eval output: {text}"
-            )
+            msg = f"Could not find score in model eval output: {text}"
+            raise OutputParserException(msg)
 
         reasoning, score_str = text.split("Score: ", maxsplit=1)
 
@@ -82,16 +84,14 @@ class TrajectoryOutputParser(BaseOutputParser):
         _score = re.search(r"(\d+(\.\d+)?)", score_str)
         # If the score is not found or is a float, raise an exception.
         if _score is None or "." in _score.group(1):
-            raise OutputParserException(
-                f"Score is not an integer digit in the range 1-5: {text}"
-            )
+            msg = f"Score is not an integer digit in the range 1-5: {text}"
+            raise OutputParserException(msg)
         score = int(_score.group(1))
         # If the score is not in the range 1-5, raise an exception.
-        if not 1 <= score <= 5:
-            raise OutputParserException(
-                f"Score is not a digit in the range 1-5: {text}"
-            )
-        normalized_score = (score - 1) / 4
+        if not 1 <= score <= _MAX_SCORE:
+            msg = f"Score is not a digit in the range 1-5: {text}"
+            raise OutputParserException(msg)
+        normalized_score = (score - 1) / (_MAX_SCORE - 1)
         return TrajectoryEval(score=normalized_score, reasoning=reasoning)
 
 
@@ -140,6 +140,7 @@ class TrajectoryEvalChain(AgentTrajectoryEvaluator, LLMEvalChain):
         )
         print(result["score"])  # noqa: T201
         # 0
+
     """
 
     agent_tools: Optional[list[BaseTool]] = None
@@ -147,7 +148,7 @@ class TrajectoryEvalChain(AgentTrajectoryEvaluator, LLMEvalChain):
     eval_chain: LLMChain
     """The language model chain used for evaluation."""
     output_parser: TrajectoryOutputParser = Field(
-        default_factory=TrajectoryOutputParser
+        default_factory=TrajectoryOutputParser,
     )
     """The output parser used to parse the output."""
     return_reasoning: bool = False  # :meta private:
@@ -176,7 +177,7 @@ class TrajectoryEvalChain(AgentTrajectoryEvaluator, LLMEvalChain):
                 f"""Tool {i}: {tool.name}
 Description: {tool.description}"""
                 for i, tool in enumerate(self.agent_tools, 1)
-            ]
+            ],
         )
 
     @staticmethod
@@ -201,7 +202,7 @@ Tool used: {action.tool}
 Tool input: {action.tool_input}
 Tool output: {output}"""
                 for i, (action, output) in enumerate(steps, 1)
-            ]
+            ],
         )
 
     @staticmethod
@@ -244,13 +245,9 @@ The following is the expected answer. Use this to measure correctness:
             TrajectoryEvalChain: The TrajectoryEvalChain object.
         """
         if not isinstance(llm, BaseChatModel):
-            raise NotImplementedError(
-                "Only chat models supported by the current trajectory eval"
-            )
-        if agent_tools:
-            prompt = EVAL_CHAT_PROMPT
-        else:
-            prompt = TOOL_FREE_EVAL_CHAT_PROMPT
+            msg = "Only chat models supported by the current trajectory eval"
+            raise NotImplementedError(msg)
+        prompt = EVAL_CHAT_PROMPT if agent_tools else TOOL_FREE_EVAL_CHAT_PROMPT
         eval_chain = LLMChain(llm=llm, prompt=prompt)
         return cls(
             agent_tools=agent_tools,  # type: ignore[arg-type]
@@ -302,9 +299,10 @@ The following is the expected answer. Use this to measure correctness:
             chain_input["tool_descriptions"] = self._tools_description
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         raw_output = self.eval_chain.run(
-            chain_input, callbacks=_run_manager.get_child()
+            chain_input,
+            callbacks=_run_manager.get_child(),
         )
-        return cast(dict, self.output_parser.parse(raw_output))
+        return cast("dict", self.output_parser.parse(raw_output))
 
     async def _acall(
         self,
@@ -326,10 +324,12 @@ The following is the expected answer. Use this to measure correctness:
             chain_input["tool_descriptions"] = self._tools_description
         _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
         raw_output = await self.eval_chain.arun(
-            chain_input, callbacks=_run_manager.get_child()
+            chain_input,
+            callbacks=_run_manager.get_child(),
         )
-        return cast(dict, self.output_parser.parse(raw_output))
+        return cast("dict", self.output_parser.parse(raw_output))
 
+    @override
     def _evaluate_agent_trajectory(
         self,
         *,
@@ -372,6 +372,7 @@ The following is the expected answer. Use this to measure correctness:
             return_only_outputs=True,
         )
 
+    @override
     async def _aevaluate_agent_trajectory(
         self,
         *,