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

langchain/evaluation/string_distance/base.py

@@ -1,466 +0,0 @@
-"""String distance evaluators based on the RapidFuzz library."""
-
-from enum import Enum
-from typing import Any, Callable, Optional
-
-from langchain_core.callbacks import Callbacks
-from langchain_core.callbacks.manager import (
-    AsyncCallbackManagerForChainRun,
-    CallbackManagerForChainRun,
-)
-from langchain_core.utils import pre_init
-from pydantic import Field
-from typing_extensions import override
-
-from langchain.chains.base import Chain
-from langchain.evaluation.schema import PairwiseStringEvaluator, StringEvaluator
-from langchain.schema import RUN_KEY
-
-
-def _load_rapidfuzz() -> Any:
-    """
-    Load the RapidFuzz library.
-
-    Raises:
-        ImportError: If the rapidfuzz library is not installed.
-
-    Returns:
-        Any: The rapidfuzz.distance module.
-    """
-    try:
-        import rapidfuzz
-    except ImportError as e:
-        msg = (
-            "Please install the rapidfuzz library to use the FuzzyMatchStringEvaluator."
-            "Please install it with `pip install rapidfuzz`."
-        )
-        raise ImportError(msg) from e
-    return rapidfuzz.distance
-
-
-class StringDistance(str, Enum):
-    """Distance metric to use.
-
-    Attributes:
-        DAMERAU_LEVENSHTEIN: The Damerau-Levenshtein distance.
-        LEVENSHTEIN: The Levenshtein distance.
-        JARO: The Jaro distance.
-        JARO_WINKLER: The Jaro-Winkler distance.
-        HAMMING: The Hamming distance.
-        INDEL: The Indel distance.
-    """
-
-    DAMERAU_LEVENSHTEIN = "damerau_levenshtein"
-    LEVENSHTEIN = "levenshtein"
-    JARO = "jaro"
-    JARO_WINKLER = "jaro_winkler"
-    HAMMING = "hamming"
-    INDEL = "indel"
-
-
-class _RapidFuzzChainMixin(Chain):
-    """Shared methods for the rapidfuzz string distance evaluators."""
-
-    distance: StringDistance = Field(default=StringDistance.JARO_WINKLER)
-    normalize_score: bool = Field(default=True)
-    """Whether to normalize the score to a value between 0 and 1.
-    Applies only to the Levenshtein and Damerau-Levenshtein distances."""
-
-    @pre_init
-    def validate_dependencies(cls, values: dict[str, Any]) -> dict[str, Any]:
-        """
-        Validate that the rapidfuzz library is installed.
-
-        Args:
-            values (Dict[str, Any]): The input values.
-
-        Returns:
-            Dict[str, Any]: The validated values.
-        """
-        _load_rapidfuzz()
-        return values
-
-    @property
-    def output_keys(self) -> list[str]:
-        """
-        Get the output keys.
-
-        Returns:
-            List[str]: The output keys.
-        """
-        return ["score"]
-
-    def _prepare_output(self, result: dict[str, Any]) -> dict[str, Any]:
-        """
-        Prepare the output dictionary.
-
-        Args:
-            result (Dict[str, Any]): The evaluation results.
-
-        Returns:
-            Dict[str, Any]: The prepared output dictionary.
-        """
-        result = {"score": result["score"]}
-        if RUN_KEY in result:
-            result[RUN_KEY] = result[RUN_KEY].dict()
-        return result
-
-    @staticmethod
-    def _get_metric(distance: str, *, normalize_score: bool = False) -> Callable:
-        """
-        Get the distance metric function based on the distance type.
-
-        Args:
-            distance (str): The distance type.
-
-        Returns:
-            Callable: The distance metric function.
-
-        Raises:
-            ValueError: If the distance metric is invalid.
-        """
-        from rapidfuzz import distance as rf_distance
-
-        module_map: dict[str, Any] = {
-            StringDistance.DAMERAU_LEVENSHTEIN: rf_distance.DamerauLevenshtein,
-            StringDistance.LEVENSHTEIN: rf_distance.Levenshtein,
-            StringDistance.JARO: rf_distance.Jaro,
-            StringDistance.JARO_WINKLER: rf_distance.JaroWinkler,
-            StringDistance.HAMMING: rf_distance.Hamming,
-            StringDistance.INDEL: rf_distance.Indel,
-        }
-        if distance not in module_map:
-            msg = (
-                f"Invalid distance metric: {distance}"
-                f"\nMust be one of: {list(StringDistance)}"
-            )
-            raise ValueError(msg)
-        module = module_map[distance]
-        if normalize_score:
-            return module.normalized_distance
-        return module.distance
-
-    @property
-    def metric(self) -> Callable:
-        """
-        Get the distance metric function.
-
-        Returns:
-            Callable: The distance metric function.
-        """
-        return _RapidFuzzChainMixin._get_metric(
-            self.distance,
-            normalize_score=self.normalize_score,
-        )
-
-    def compute_metric(self, a: str, b: str) -> float:
-        """
-        Compute the distance between two strings.
-
-        Args:
-            a (str): The first string.
-            b (str): The second string.
-
-        Returns:
-            float: The distance between the two strings.
-        """
-        return self.metric(a, b)
-
-
-class StringDistanceEvalChain(StringEvaluator, _RapidFuzzChainMixin):
-    """Compute string distances between the prediction and the reference.
-
-    Examples
-    ----------
-
-    >>> from langchain.evaluation import StringDistanceEvalChain
-    >>> evaluator = StringDistanceEvalChain()
-    >>> evaluator.evaluate_strings(
-            prediction="Mindy is the CTO",
-            reference="Mindy is the CEO",
-        )
-
-    Using the `load_evaluator` function:
-
-    >>> from langchain.evaluation import load_evaluator
-    >>> evaluator = load_evaluator("string_distance")
-    >>> evaluator.evaluate_strings(
-            prediction="The answer is three",
-            reference="three",
-        )
-    """
-
-    @property
-    def requires_input(self) -> bool:
-        """
-        This evaluator does not require input.
-        """
-        return False
-
-    @property
-    def requires_reference(self) -> bool:
-        """
-        This evaluator does not require a reference.
-        """
-        return True
-
-    @property
-    def input_keys(self) -> list[str]:
-        """
-        Get the input keys.
-
-        Returns:
-            List[str]: The input keys.
-        """
-        return ["reference", "prediction"]
-
-    @property
-    def evaluation_name(self) -> str:
-        """
-        Get the evaluation name.
-
-        Returns:
-            str: The evaluation name.
-        """
-        return f"{self.distance.value}_distance"
-
-    def _call(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        """
-        Compute the string distance between the prediction and the reference.
-
-        Args:
-            inputs (Dict[str, Any]): The input values.
-            run_manager (Optional[CallbackManagerForChainRun]):
-                The callback manager.
-
-        Returns:
-            Dict[str, Any]: The evaluation results containing the score.
-        """
-        return {"score": self.compute_metric(inputs["reference"], inputs["prediction"])}
-
-    async def _acall(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        """
-        Asynchronously compute the string distance between the prediction
-            and the reference.
-
-        Args:
-            inputs (Dict[str, Any]): The input values.
-            run_manager (Optional[AsyncCallbackManagerForChainRun]:
-                The callback manager.
-
-        Returns:
-            Dict[str, Any]: The evaluation results containing the score.
-        """
-        return {"score": self.compute_metric(inputs["reference"], inputs["prediction"])}
-
-    @override
-    def _evaluate_strings(
-        self,
-        *,
-        prediction: str,
-        reference: Optional[str] = None,
-        input: Optional[str] = None,
-        callbacks: Callbacks = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        """
-        Evaluate the string distance between the prediction and the reference.
-
-        Args:
-            prediction (str): The prediction string.
-            reference (Optional[str], optional): The reference string.
-            input (Optional[str], optional): The input string.
-            callbacks (Callbacks, optional): The callbacks to use.
-            kwargs: Additional keyword arguments.
-
-        Returns:
-            dict: The evaluation results containing the score.
-        """
-        result = self(
-            inputs={"prediction": prediction, "reference": reference},
-            callbacks=callbacks,
-            tags=tags,
-            metadata=metadata,
-            include_run_info=include_run_info,
-        )
-
-        return self._prepare_output(result)
-
-    @override
-    async def _aevaluate_strings(
-        self,
-        *,
-        prediction: str,
-        reference: Optional[str] = None,
-        input: Optional[str] = None,
-        callbacks: Callbacks = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        """
-        Asynchronously evaluate the string distance between the
-            prediction and the reference.
-
-        Args:
-            prediction (str): The prediction string.
-            reference (Optional[str], optional): The reference string.
-            input (Optional[str], optional): The input string.
-            callbacks (Callbacks, optional): The callbacks to use.
-            kwargs: Additional keyword arguments.
-
-        Returns:
-            dict: The evaluation results containing the score.
-        """
-        result = await self.acall(
-            inputs={"prediction": prediction, "reference": reference},
-            callbacks=callbacks,
-            tags=tags,
-            metadata=metadata,
-            include_run_info=include_run_info,
-        )
-        return self._prepare_output(result)
-
-
-class PairwiseStringDistanceEvalChain(PairwiseStringEvaluator, _RapidFuzzChainMixin):
-    """Compute string edit distances between two predictions."""
-
-    @property
-    def input_keys(self) -> list[str]:
-        """
-        Get the input keys.
-
-        Returns:
-            List[str]: The input keys.
-        """
-        return ["prediction", "prediction_b"]
-
-    @property
-    def evaluation_name(self) -> str:
-        """
-        Get the evaluation name.
-
-        Returns:
-            str: The evaluation name.
-        """
-        return f"pairwise_{self.distance.value}_distance"
-
-    def _call(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        """
-        Compute the string distance between two predictions.
-
-        Args:
-            inputs (Dict[str, Any]): The input values.
-            run_manager (CallbackManagerForChainRun , optional):
-                The callback manager.
-
-        Returns:
-            Dict[str, Any]: The evaluation results containing the score.
-        """
-        return {
-            "score": self.compute_metric(inputs["prediction"], inputs["prediction_b"]),
-        }
-
-    async def _acall(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        """
-        Asynchronously compute the string distance between two predictions.
-
-        Args:
-            inputs (Dict[str, Any]): The input values.
-            run_manager (AsyncCallbackManagerForChainRun , optional):
-                The callback manager.
-
-        Returns:
-            Dict[str, Any]: The evaluation results containing the score.
-        """
-        return {
-            "score": self.compute_metric(inputs["prediction"], inputs["prediction_b"]),
-        }
-
-    def _evaluate_string_pairs(
-        self,
-        *,
-        prediction: str,
-        prediction_b: str,
-        callbacks: Callbacks = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        """
-        Evaluate the string distance between two predictions.
-
-        Args:
-            prediction (str): The first prediction string.
-            prediction_b (str): The second prediction string.
-            callbacks (Callbacks, optional): The callbacks to use.
-            tags (List[str], optional): Tags to apply to traces.
-            metadata (Dict[str, Any], optional): Metadata to apply to traces.
-            kwargs: Additional keyword arguments.
-
-        Returns:
-            dict: The evaluation results containing the score.
-        """
-        result = self(
-            inputs={"prediction": prediction, "prediction_b": prediction_b},
-            callbacks=callbacks,
-            tags=tags,
-            metadata=metadata,
-            include_run_info=include_run_info,
-        )
-        return self._prepare_output(result)
-
-    async def _aevaluate_string_pairs(
-        self,
-        *,
-        prediction: str,
-        prediction_b: str,
-        callbacks: Callbacks = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        """
-        Asynchronously evaluate the string distance between two predictions.
-
-        Args:
-            prediction (str): The first prediction string.
-            prediction_b (str): The second prediction string.
-            callbacks (Callbacks, optional): The callbacks to use.
-            tags (List[str], optional): Tags to apply to traces.
-            metadata (Dict[str, Any], optional): Metadata to apply to traces.
-            kwargs: Additional keyword arguments.
-
-        Returns:
-            dict: The evaluation results containing the score.
-        """
-        result = await self.acall(
-            inputs={"prediction": prediction, "prediction_b": prediction_b},
-            callbacks=callbacks,
-            tags=tags,
-            metadata=metadata,
-            include_run_info=include_run_info,
-        )
-        return self._prepare_output(result)

langchain/example_generator.py

@@ -1,5 +0,0 @@
-"""Keep here for backwards compatibility."""
-
-from langchain.chains.example_generator import generate_example
-
-__all__ = ["generate_example"]

langchain/formatting.py

@@ -1,5 +0,0 @@
-"""DEPRECATED: Kept for backwards compatibility."""
-
-from langchain_core.utils.formatting import StrictFormatter, formatter
-
-__all__ = ["StrictFormatter", "formatter"]

langchain/globals.py

@@ -1,180 +0,0 @@
-"""Global values and configuration that apply to all of LangChain."""
-
-import warnings
-from typing import TYPE_CHECKING, Optional
-
-if TYPE_CHECKING:
-    from langchain_core.caches import BaseCache
-
-
-# DO NOT USE THESE VALUES DIRECTLY!
-# Use them only via `get_<X>()` and `set_<X>()` below,
-# or else your code may behave unexpectedly with other uses of these global settings:
-# https://github.com/langchain-ai/langchain/pull/11311#issuecomment-1743780004
-_verbose: bool = False
-_debug: bool = False
-_llm_cache: Optional["BaseCache"] = None
-
-
-def set_verbose(
-    value: bool,  # noqa: FBT001
-) -> None:
-    """Set a new value for the `verbose` global setting."""
-    import langchain
-
-    # We're about to run some deprecated code, don't report warnings from it.
-    # The user called the correct (non-deprecated) code path and shouldn't get warnings.
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            message=(
-                "Importing verbose from langchain root module is no longer supported"
-            ),
-        )
-        # N.B.: This is a workaround for an unfortunate quirk of Python's
-        #       module-level `__getattr__()` implementation:
-        # https://github.com/langchain-ai/langchain/pull/11311#issuecomment-1743780004
-        #
-        # Remove it once `langchain.verbose` is no longer supported, and once all users
-        # have migrated to using `set_verbose()` here.
-        langchain.verbose = value
-
-    global _verbose  # noqa: PLW0603
-    _verbose = value
-
-
-def get_verbose() -> bool:
-    """Get the value of the `verbose` global setting."""
-    import langchain
-
-    # We're about to run some deprecated code, don't report warnings from it.
-    # The user called the correct (non-deprecated) code path and shouldn't get warnings.
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            message=(
-                "Importing verbose from langchain root module is no longer supported"
-            ),
-        )
-        # N.B.: This is a workaround for an unfortunate quirk of Python's
-        #       module-level `__getattr__()` implementation:
-        # https://github.com/langchain-ai/langchain/pull/11311#issuecomment-1743780004
-        #
-        # Remove it once `langchain.verbose` is no longer supported, and once all users
-        # have migrated to using `set_verbose()` here.
-        #
-        # In the meantime, the `verbose` setting is considered True if either the old
-        # or the new value are True. This accommodates users who haven't migrated
-        # to using `set_verbose()` yet. Those users are getting deprecation warnings
-        # directing them to use `set_verbose()` when they import `langchain.verbose`.
-        old_verbose = langchain.verbose
-
-    return _verbose or old_verbose
-
-
-def set_debug(
-    value: bool,  # noqa: FBT001
-) -> None:
-    """Set a new value for the `debug` global setting."""
-    import langchain
-
-    # We're about to run some deprecated code, don't report warnings from it.
-    # The user called the correct (non-deprecated) code path and shouldn't get warnings.
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            message="Importing debug from langchain root module is no longer supported",
-        )
-        # N.B.: This is a workaround for an unfortunate quirk of Python's
-        #       module-level `__getattr__()` implementation:
-        # https://github.com/langchain-ai/langchain/pull/11311#issuecomment-1743780004
-        #
-        # Remove it once `langchain.debug` is no longer supported, and once all users
-        # have migrated to using `set_debug()` here.
-        langchain.debug = value
-
-    global _debug  # noqa: PLW0603
-    _debug = value
-
-
-def get_debug() -> bool:
-    """Get the value of the `debug` global setting."""
-    import langchain
-
-    # We're about to run some deprecated code, don't report warnings from it.
-    # The user called the correct (non-deprecated) code path and shouldn't get warnings.
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            message="Importing debug from langchain root module is no longer supported",
-        )
-        # N.B.: This is a workaround for an unfortunate quirk of Python's
-        #       module-level `__getattr__()` implementation:
-        # https://github.com/langchain-ai/langchain/pull/11311#issuecomment-1743780004
-        #
-        # Remove it once `langchain.debug` is no longer supported, and once all users
-        # have migrated to using `set_debug()` here.
-        #
-        # In the meantime, the `debug` setting is considered True if either the old
-        # or the new value are True. This accommodates users who haven't migrated
-        # to using `set_debug()` yet. Those users are getting deprecation warnings
-        # directing them to use `set_debug()` when they import `langchain.debug`.
-        old_debug = langchain.debug
-
-    return _debug or old_debug
-
-
-def set_llm_cache(value: Optional["BaseCache"]) -> None:
-    """Set a new LLM cache, overwriting the previous value, if any."""
-    import langchain
-
-    # We're about to run some deprecated code, don't report warnings from it.
-    # The user called the correct (non-deprecated) code path and shouldn't get warnings.
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            message=(
-                "Importing llm_cache from langchain root module is no longer supported"
-            ),
-        )
-        # N.B.: This is a workaround for an unfortunate quirk of Python's
-        #       module-level `__getattr__()` implementation:
-        # https://github.com/langchain-ai/langchain/pull/11311#issuecomment-1743780004
-        #
-        # Remove it once `langchain.llm_cache` is no longer supported, and
-        # once all users have migrated to using `set_llm_cache()` here.
-        langchain.llm_cache = value
-
-    global _llm_cache  # noqa: PLW0603
-    _llm_cache = value
-
-
-def get_llm_cache() -> "BaseCache":
-    """Get the value of the `llm_cache` global setting."""
-    import langchain
-
-    # We're about to run some deprecated code, don't report warnings from it.
-    # The user called the correct (non-deprecated) code path and shouldn't get warnings.
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            message=(
-                "Importing llm_cache from langchain root module is no longer supported"
-            ),
-        )
-        # N.B.: This is a workaround for an unfortunate quirk of Python's
-        #       module-level `__getattr__()` implementation:
-        # https://github.com/langchain-ai/langchain/pull/11311#issuecomment-1743780004
-        #
-        # Remove it once `langchain.llm_cache` is no longer supported, and
-        # once all users have migrated to using `set_llm_cache()` here.
-        #
-        # In the meantime, the `llm_cache` setting returns whichever of
-        # its two backing sources is truthy (not `None` and non-empty),
-        # or the old value if both are falsy. This accommodates users
-        # who haven't migrated to using `set_llm_cache()` yet.
-        # Those users are getting deprecation warnings directing them
-        # to use `set_llm_cache()` when they import `langchain.llm_cache`.
-        old_llm_cache = langchain.llm_cache
-
-    return _llm_cache or old_llm_cache