langchain 0.3.26__py3-none-any.whl → 0.3.27__py3-none-any.whl

langchain/embeddings/base.py

@@ -50,7 +50,7 @@ def _parse_model_string(model_name: str) -> tuple[str, str]:
     """
     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 +59,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 +116,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(
@@ -172,9 +180,10 @@ def init_embeddings(
     """
     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 +193,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
 
@@ -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)
 
 
@@ -147,7 +147,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 +176,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 +201,7 @@ Tool used: {action.tool}
 Tool input: {action.tool_input}
 Tool output: {output}"""
                 for i, (action, output) in enumerate(steps, 1)
-            ]
+            ],
         )
 
     @staticmethod
@@ -244,13 +244,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,7 +298,8 @@ 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))
 
@@ -326,10 +323,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))
 
+    @override
     def _evaluate_agent_trajectory(
         self,
         *,
@@ -372,6 +371,7 @@ The following is the expected answer. Use this to measure correctness:
             return_only_outputs=True,
         )
 
+    @override
     async def _aevaluate_agent_trajectory(
         self,
         *,

langchain/evaluation/agents/trajectory_eval_prompt.py

@@ -1,14 +1,11 @@
 """Prompt for trajectory evaluation chain."""
 
-# flake8: noqa
-from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
-
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
 from langchain_core.prompts.chat import (
     ChatPromptTemplate,
     HumanMessagePromptTemplate,
 )
 
-
 EVAL_TEMPLATE = """An AI language model has been given access to the following set of tools to help answer a user's question.
 
 The tools given to the AI model are:
@@ -39,7 +36,7 @@ i. Is the final answer helpful?
 ii. Does the AI language use a logical sequence of tools to answer the question?
 iii. Does the AI language model use the tools in a helpful way?
 iv. Does the AI language model use too many steps to answer the question?
-v. Are the appropriate tools used to answer the question?"""
+v. Are the appropriate tools used to answer the question?"""  # noqa: E501
 
 EXAMPLE_INPUT = """An AI language model has been given access to the following set of tools to help answer a user's question.
 
@@ -84,7 +81,7 @@ i. Is the final answer helpful?
 ii. Does the AI language use a logical sequence of tools to answer the question?
 iii. Does the AI language model use the tools in a helpful way?
 iv. Does the AI language model use too many steps to answer the question?
-v. Are the appropriate tools used to answer the question?"""
+v. Are the appropriate tools used to answer the question?"""  # noqa: E501
 
 EXAMPLE_OUTPUT = """First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\
 The model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\
@@ -92,10 +89,10 @@ The way model uses the search is not helpful. The model should have used the sea
 The model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\
 The tools were not used in a helpful way. The model did not use too many steps to answer the question.\
 The model did not use the appropriate tools to answer the question.\
-    
+
 Judgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.
 
-Score: 2"""
+Score: 2"""  # noqa: E501
 
 EVAL_CHAT_PROMPT = ChatPromptTemplate.from_messages(
     messages=[
@@ -134,7 +131,7 @@ i. Is the final answer helpful?
 ii. Does the AI language use a logical sequence of tools to answer the question?
 iii. Does the AI language model use the tools in a helpful way?
 iv. Does the AI language model use too many steps to answer the question?
-v. Are the appropriate tools used to answer the question?"""
+v. Are the appropriate tools used to answer the question?"""  # noqa: E501
 
 
 TOOL_FREE_EVAL_CHAT_PROMPT = ChatPromptTemplate.from_messages(

langchain/evaluation/comparison/__init__.py

@@ -33,4 +33,4 @@ from langchain.evaluation.comparison.eval_chain import (
     PairwiseStringEvalChain,
 )
 
-__all__ = ["PairwiseStringEvalChain", "LabeledPairwiseStringEvalChain"]
+__all__ = ["LabeledPairwiseStringEvalChain", "PairwiseStringEvalChain"]