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

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"]

langchain/evaluation/comparison/eval_chain.py

@@ -11,6 +11,7 @@ from langchain_core.language_models import BaseLanguageModel
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.prompts.prompt import PromptTemplate
 from pydantic import ConfigDict, Field
+from typing_extensions import override
 
 from langchain.chains.constitutional_ai.models import ConstitutionalPrinciple
 from langchain.chains.llm import LLMChain
@@ -69,7 +70,7 @@ def resolve_pairwise_criteria(
             Criteria.DEPTH,
         ]
         return {k.value: _SUPPORTED_CRITERIA[k] for k in _default_criteria}
-    elif isinstance(criteria, Criteria):
+    if isinstance(criteria, Criteria):
         criteria_ = {criteria.value: _SUPPORTED_CRITERIA[criteria]}
     elif isinstance(criteria, str):
         if criteria in _SUPPORTED_CRITERIA:
@@ -86,11 +87,12 @@ def resolve_pairwise_criteria(
         }
     else:
         if not criteria:
-            raise ValueError(
+            msg = (
                 "Criteria cannot be empty. "
                 "Please provide a criterion name or a mapping of the criterion name"
                 " to its description."
             )
+            raise ValueError(msg)
         criteria_ = dict(criteria)
     return criteria_
 
@@ -132,11 +134,12 @@ class PairwiseStringResultOutputParser(BaseOutputParser[dict]):
             verdict = match.group(1)
 
         if not match or verdict not in {"A", "B", "C"}:
-            raise ValueError(
+            msg = (
                 f"Invalid output: {text}. "
                 "Output must contain a double bracketed string\
                  with the verdict 'A', 'B', or 'C'."
             )
+            raise ValueError(msg)
         # C means the models are tied. Return 'None' meaning no preference
         verdict_ = None if verdict == "C" else verdict
         score = {
@@ -184,10 +187,11 @@ class PairwiseStringEvalChain(PairwiseStringEvaluator, LLMEvalChain, LLMChain):
 
     output_key: str = "results"  #: :meta private:
     output_parser: BaseOutputParser = Field(
-        default_factory=PairwiseStringResultOutputParser
+        default_factory=PairwiseStringResultOutputParser,
     )
 
     @classmethod
+    @override
     def is_lc_serializable(cls) -> bool:
         return False
 
@@ -256,16 +260,17 @@ class PairwiseStringEvalChain(PairwiseStringEvaluator, LLMEvalChain, LLMChain):
         if not hasattr(llm, "model_name") or not llm.model_name.startswith("gpt-4"):
             logger.warning(
                 "This chain was only tested with GPT-4. \
-Performance may be significantly worse with other models."
+Performance may be significantly worse with other models.",
             )
 
         expected_input_vars = {"prediction", "prediction_b", "input", "criteria"}
         prompt_ = prompt or COMPARISON_TEMPLATE.partial(reference="")
         if expected_input_vars != set(prompt_.input_variables):
-            raise ValueError(
+            msg = (
                 f"Input variables should be {expected_input_vars}, "
                 f"but got {prompt_.input_variables}"
             )
+            raise ValueError(msg)
         criteria_ = resolve_pairwise_criteria(criteria)
         criteria_str = "\n".join(f"{k}: {v}" if v else k for k, v in criteria_.items())
         criteria_str = CRITERIA_INSTRUCTIONS + criteria_str if criteria_str else ""
@@ -275,7 +280,7 @@ Performance may be significantly worse with other models."
         self,
         prediction: str,
         prediction_b: str,
-        input: Optional[str],
+        input_: Optional[str],
         reference: Optional[str],
     ) -> dict:
         """Prepare the input for the chain.
@@ -283,21 +288,21 @@ Performance may be significantly worse with other models."
         Args:
             prediction (str): The output string from the first model.
             prediction_b (str): The output string from the second model.
-            input (str, optional): The input or task string.
+            input_ (str, optional): The input or task string.
             reference (str, optional): The reference string, if any.
 
         Returns:
             dict: The prepared input for the chain.
 
         """
-        input_ = {
+        input_dict = {
             "prediction": prediction,
             "prediction_b": prediction_b,
-            "input": input,
+            "input": input_,
         }
         if self.requires_reference:
-            input_["reference"] = reference
-        return input_
+            input_dict["reference"] = reference
+        return input_dict
 
     def _prepare_output(self, result: dict) -> dict:
         """Prepare the output."""
@@ -306,6 +311,7 @@ Performance may be significantly worse with other models."
             parsed[RUN_KEY] = result[RUN_KEY]
         return parsed
 
+    @override
     def _evaluate_string_pairs(
         self,
         *,
@@ -348,6 +354,7 @@ Performance may be significantly worse with other models."
         )
         return self._prepare_output(result)
 
+    @override
     async def _aevaluate_string_pairs(
         self,
         *,
@@ -444,10 +451,11 @@ class LabeledPairwiseStringEvalChain(PairwiseStringEvalChain):
         }
         prompt_ = prompt or COMPARISON_TEMPLATE_WITH_REFERENCE
         if expected_input_vars != set(prompt_.input_variables):
-            raise ValueError(
+            msg = (
                 f"Input variables should be {expected_input_vars}, "
                 f"but got {prompt_.input_variables}"
             )
+            raise ValueError(msg)
         criteria_ = resolve_pairwise_criteria(criteria)
         criteria_str = "\n".join(f"{k}: {v}" for k, v in criteria_.items())
         criteria_str = CRITERIA_INSTRUCTIONS + criteria_str if criteria_str else ""

langchain/evaluation/comparison/prompt.py

@@ -3,9 +3,8 @@
 This prompt is used to compare two responses and evaluate which one best follows the instructions
 and answers the question. The prompt is based on the paper from
 Zheng, et. al. https://arxiv.org/abs/2306.05685
-"""
+"""  # noqa: E501
 
-# flake8: noqa
 from langchain_core.prompts.chat import ChatPromptTemplate
 
 SYSTEM_MESSAGE = 'Please act as an impartial judge and evaluate the quality \

langchain/evaluation/criteria/__init__.py

@@ -53,4 +53,4 @@ from langchain.evaluation.criteria.eval_chain import (
     LabeledCriteriaEvalChain,
 )
 
-__all__ = ["CriteriaEvalChain", "LabeledCriteriaEvalChain", "Criteria"]
+__all__ = ["Criteria", "CriteriaEvalChain", "LabeledCriteriaEvalChain"]

langchain/evaluation/criteria/eval_chain.py

@@ -10,6 +10,7 @@ from langchain_core.language_models import BaseLanguageModel
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.prompts import BasePromptTemplate
 from pydantic import ConfigDict, Field
+from typing_extensions import override
 
 from langchain.chains.constitutional_ai.models import ConstitutionalPrinciple
 from langchain.chains.llm import LLMChain
@@ -156,11 +157,12 @@ def resolve_criteria(
         criteria_ = {criteria.name: criteria.critique_request}
     else:
         if not criteria:
-            raise ValueError(
+            msg = (
                 "Criteria cannot be empty. "
                 "Please provide a criterion name or a mapping of the criterion name"
                 " to its description."
             )
+            raise ValueError(msg)
         criteria_ = dict(criteria)
     return criteria_
 
@@ -234,6 +236,7 @@ class CriteriaEvalChain(StringEvaluator, LLMEvalChain, LLMChain):
     output_key: str = "results"  #: :meta private:
 
     @classmethod
+    @override
     def is_lc_serializable(cls) -> bool:
         return False
 
@@ -247,6 +250,7 @@ class CriteriaEvalChain(StringEvaluator, LLMEvalChain, LLMChain):
         return False
 
     @property
+    @override
     def requires_input(self) -> bool:
         return True
 
@@ -271,15 +275,17 @@ class CriteriaEvalChain(StringEvaluator, LLMEvalChain, LLMChain):
 
     @classmethod
     def _resolve_prompt(
-        cls, prompt: Optional[BasePromptTemplate] = None
+        cls,
+        prompt: Optional[BasePromptTemplate] = None,
     ) -> BasePromptTemplate:
         expected_input_vars = {"input", "output", "criteria"}
         prompt_ = prompt or PROMPT
         if expected_input_vars != set(prompt_.input_variables):
-            raise ValueError(
+            msg = (
                 f"Input variables should be {expected_input_vars}, "
                 f"but got {prompt_.input_variables}"
             )
+            raise ValueError(msg)
         return prompt_
 
     @classmethod
@@ -360,12 +366,13 @@ class CriteriaEvalChain(StringEvaluator, LLMEvalChain, LLMChain):
         """
         prompt_ = cls._resolve_prompt(prompt)
         if criteria == Criteria.CORRECTNESS:
-            raise ValueError(
+            msg = (
                 "Correctness should not be used in the reference-free"
                 " 'criteria' evaluator (CriteriaEvalChain)."
                 " Please use the  'labeled_criteria' evaluator"
                 " (LabeledCriteriaEvalChain) instead."
             )
+            raise ValueError(msg)
         criteria_ = cls.resolve_criteria(criteria)
         criteria_str = "\n".join(f"{k}: {v}" for k, v in criteria_.items())
         prompt_ = prompt_.partial(criteria=criteria_str)
@@ -380,16 +387,16 @@ class CriteriaEvalChain(StringEvaluator, LLMEvalChain, LLMChain):
         self,
         prediction: str,
         reference: Optional[str],
-        input: Optional[str],
+        input_: Optional[str],
     ) -> dict:
         """Get the evaluation input."""
-        input_ = {
-            "input": input,
+        input_dict = {
+            "input": input_,
             "output": prediction,
         }
         if self.requires_reference:
-            input_["reference"] = reference
-        return input_
+            input_dict["reference"] = reference
+        return input_dict
 
     def _prepare_output(self, result: dict) -> dict:
         """Prepare the output."""
@@ -398,6 +405,7 @@ class CriteriaEvalChain(StringEvaluator, LLMEvalChain, LLMChain):
             parsed[RUN_KEY] = result[RUN_KEY]
         return parsed
 
+    @override
     def _evaluate_strings(
         self,
         *,
@@ -453,6 +461,7 @@ class CriteriaEvalChain(StringEvaluator, LLMEvalChain, LLMChain):
         )
         return self._prepare_output(result)
 
+    @override
     async def _aevaluate_strings(
         self,
         *,
@@ -513,6 +522,7 @@ class LabeledCriteriaEvalChain(CriteriaEvalChain):
     """Criteria evaluation chain that requires references."""
 
     @classmethod
+    @override
     def is_lc_serializable(cls) -> bool:
         return False
 
@@ -523,15 +533,17 @@ class LabeledCriteriaEvalChain(CriteriaEvalChain):
 
     @classmethod
     def _resolve_prompt(
-        cls, prompt: Optional[BasePromptTemplate] = None
+        cls,
+        prompt: Optional[BasePromptTemplate] = None,
     ) -> BasePromptTemplate:
         expected_input_vars = {"input", "output", "criteria", "reference"}
         prompt_ = prompt or PROMPT_WITH_REFERENCES
         if expected_input_vars != set(prompt_.input_variables):
-            raise ValueError(
+            msg = (
                 f"Input variables should be {expected_input_vars}, "
                 f"but got {prompt_.input_variables}"
             )
+            raise ValueError(msg)
         return prompt_
 
     @classmethod

langchain/evaluation/criteria/prompt.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 # Credit to https://github.com/openai/evals/tree/main
 
 from langchain_core.prompts import PromptTemplate
@@ -13,7 +12,7 @@ template = """You are assessing a submitted answer on a given task or input base
 [Criteria]: {criteria}
 ***
 [END DATA]
-Does the submission meet the Criteria? First, write out in a step by step manner your reasoning about each criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer of whether the submission meets all criteria. At the end, repeat just the letter again by itself on a new line."""
+Does the submission meet the Criteria? First, write out in a step by step manner your reasoning about each criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer of whether the submission meets all criteria. At the end, repeat just the letter again by itself on a new line."""  # noqa: E501
 
 PROMPT = PromptTemplate(
     input_variables=["input", "output", "criteria"], template=template
@@ -31,7 +30,7 @@ template = """You are assessing a submitted answer on a given task or input base
 [Reference]: {reference}
 ***
 [END DATA]
-Does the submission meet the Criteria? First, write out in a step by step manner your reasoning about each criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer of whether the submission meets all criteria. At the end, repeat just the letter again by itself on a new line."""
+Does the submission meet the Criteria? First, write out in a step by step manner your reasoning about each criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer of whether the submission meets all criteria. At the end, repeat just the letter again by itself on a new line."""  # noqa: E501
 
 PROMPT_WITH_REFERENCES = PromptTemplate(
     input_variables=["input", "output", "criteria", "reference"], template=template

langchain/evaluation/embedding_distance/base.py

@@ -14,6 +14,7 @@ from langchain_core.callbacks.manager import (
 from langchain_core.embeddings import Embeddings
 from langchain_core.utils import pre_init
 from pydantic import ConfigDict, Field
+from typing_extensions import override
 
 from langchain.chains.base import Chain
 from langchain.evaluation.schema import PairwiseStringEvaluator, StringEvaluator
@@ -23,12 +24,10 @@ from langchain.schema import RUN_KEY
 def _import_numpy() -> Any:
     try:
         import numpy as np
-
-        return np
     except ImportError as e:
-        raise ImportError(
-            "Could not import numpy, please install with `pip install numpy`."
-        ) from e
+        msg = "Could not import numpy, please install with `pip install numpy`."
+        raise ImportError(msg) from e
+    return np
 
 
 logger = logging.getLogger(__name__)
@@ -43,7 +42,7 @@ def _check_numpy() -> bool:
         "langchain will use a pure Python implementation for embedding distance "
         "operations, which may significantly impact performance, especially for large "
         "datasets. For optimal speed and efficiency, consider installing NumPy: "
-        "pip install numpy"
+        "pip install numpy",
     )
     return False
 
@@ -63,11 +62,12 @@ def _embedding_factory() -> Embeddings:
             from langchain_community.embeddings.openai import (  # type: ignore[no-redef]
                 OpenAIEmbeddings,
             )
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "Could not import OpenAIEmbeddings. Please install the "
                 "OpenAIEmbeddings package using `pip install langchain-openai`."
             )
+            raise ImportError(msg) from e
     return OpenAIEmbeddings()
 
 
@@ -130,21 +130,23 @@ class _EmbeddingDistanceChainMixin(Chain):
             pass
 
         if not types_:
-            raise ImportError(
+            msg = (
                 "Could not import OpenAIEmbeddings. Please install the "
                 "OpenAIEmbeddings package using `pip install langchain-openai`."
             )
+            raise ImportError(msg)
 
         if isinstance(embeddings, tuple(types_)):
             try:
                 import tiktoken  # noqa: F401
-            except ImportError:
-                raise ImportError(
+            except ImportError as e:
+                msg = (
                     "The tiktoken library is required to use the default "
                     "OpenAI embeddings with embedding distance evaluators."
                     " Please either manually select a different Embeddings object"
                     " or install tiktoken using `pip install tiktoken`."
                 )
+                raise ImportError(msg) from e
         return values
 
     model_config = ConfigDict(
@@ -184,8 +186,8 @@ class _EmbeddingDistanceChainMixin(Chain):
         }
         if metric in metrics:
             return metrics[metric]
-        else:
-            raise ValueError(f"Invalid metric: {metric}")
+        msg = f"Invalid metric: {metric}"
+        raise ValueError(msg)
 
     @staticmethod
     def _cosine_distance(a: Any, b: Any) -> Any:
@@ -200,12 +202,13 @@ class _EmbeddingDistanceChainMixin(Chain):
         """
         try:
             from langchain_community.utils.math import cosine_similarity
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "The cosine_similarity function is required to compute cosine distance."
                 " Please install the langchain-community package using"
                 " `pip install langchain-community`."
             )
+            raise ImportError(msg) from e
         return 1.0 - cosine_similarity(a, b)
 
     @staticmethod
@@ -315,6 +318,7 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
         return True
 
     @property
+    @override
     def evaluation_name(self) -> str:
         return f"embedding_{self.distance_metric.value}_distance"
 
@@ -327,6 +331,7 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
         """
         return ["prediction", "reference"]
 
+    @override
     def _call(
         self,
         inputs: dict[str, Any],
@@ -343,7 +348,7 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
             Dict[str, Any]: The computed score.
         """
         vectors = self.embeddings.embed_documents(
-            [inputs["prediction"], inputs["reference"]]
+            [inputs["prediction"], inputs["reference"]],
         )
         if _check_numpy():
             np = _import_numpy()
@@ -351,6 +356,7 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
         score = self._compute_score(vectors)
         return {"score": score}
 
+    @override
     async def _acall(
         self,
         inputs: dict[str, Any],
@@ -370,7 +376,7 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
             [
                 inputs["prediction"],
                 inputs["reference"],
-            ]
+            ],
         )
         if _check_numpy():
             np = _import_numpy()
@@ -378,6 +384,7 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
         score = self._compute_score(vectors)
         return {"score": score}
 
+    @override
     def _evaluate_strings(
         self,
         *,
@@ -412,6 +419,7 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
         )
         return self._prepare_output(result)
 
+    @override
     async def _aevaluate_strings(
         self,
         *,
@@ -448,7 +456,8 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
 
 
 class PairwiseEmbeddingDistanceEvalChain(
-    _EmbeddingDistanceChainMixin, PairwiseStringEvaluator
+    _EmbeddingDistanceChainMixin,
+    PairwiseStringEvaluator,
 ):
     """Use embedding distances to score semantic difference between two predictions.
 
@@ -470,8 +479,10 @@ class PairwiseEmbeddingDistanceEvalChain(
 
     @property
     def evaluation_name(self) -> str:
+        """Return the evaluation name."""
         return f"pairwise_embedding_{self.distance_metric.value}_distance"
 
+    @override
     def _call(
         self,
         inputs: dict[str, Any],
@@ -491,7 +502,7 @@ class PairwiseEmbeddingDistanceEvalChain(
             [
                 inputs["prediction"],
                 inputs["prediction_b"],
-            ]
+            ],
         )
         if _check_numpy():
             np = _import_numpy()
@@ -499,6 +510,7 @@ class PairwiseEmbeddingDistanceEvalChain(
         score = self._compute_score(vectors)
         return {"score": score}
 
+    @override
     async def _acall(
         self,
         inputs: dict[str, Any],
@@ -518,7 +530,7 @@ class PairwiseEmbeddingDistanceEvalChain(
             [
                 inputs["prediction"],
                 inputs["prediction_b"],
-            ]
+            ],
         )
         if _check_numpy():
             np = _import_numpy()
@@ -526,6 +538,7 @@ class PairwiseEmbeddingDistanceEvalChain(
         score = self._compute_score(vectors)
         return {"score": score}
 
+    @override
     def _evaluate_string_pairs(
         self,
         *,
@@ -561,6 +574,7 @@ class PairwiseEmbeddingDistanceEvalChain(
         )
         return self._prepare_output(result)
 
+    @override
     async def _aevaluate_string_pairs(
         self,
         *,

langchain/evaluation/exact_match/base.py

@@ -1,6 +1,8 @@
 import string
 from typing import Any
 
+from typing_extensions import override
+
 from langchain.evaluation.schema import StringEvaluator
 
 
@@ -27,8 +29,18 @@ class ExactMatchStringEvaluator(StringEvaluator):
         ignore_case: bool = False,
         ignore_punctuation: bool = False,
         ignore_numbers: bool = False,
-        **kwargs: Any,
+        **_: Any,
     ):
+        """Initialize the ExactMatchStringEvaluator.
+
+        Args:
+            ignore_case: Whether to ignore case when comparing strings.
+                Defaults to False.
+            ignore_punctuation: Whether to ignore punctuation when comparing strings.
+                Defaults to False.
+            ignore_numbers: Whether to ignore numbers when comparing strings.
+                Defaults to False.
+        """
         super().__init__()
         self.ignore_case = ignore_case
         self.ignore_punctuation = ignore_punctuation
@@ -68,6 +80,7 @@ class ExactMatchStringEvaluator(StringEvaluator):
         """
         return "exact_match"
 
+    @override
     def _evaluate_strings(  # type: ignore[override]
         self,
         *,