langchain 0.4.0.dev0__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

langchain/evaluation/string_distance/base.py

@@ -1,472 +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"
-
-    @override
-    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"])}
-
-    @override
-    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"
-
-    @override
-    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"]),
-        }
-
-    @override
-    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"]),
-        }
-
-    @override
-    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)
-
-    @override
-    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/graphs/__init__.py

@@ -1,57 +0,0 @@
-"""**Graphs** provide a natural language interface to graph databases."""
-
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.graphs import (
-        ArangoGraph,
-        FalkorDBGraph,
-        HugeGraph,
-        KuzuGraph,
-        MemgraphGraph,
-        NebulaGraph,
-        Neo4jGraph,
-        NeptuneGraph,
-        NetworkxEntityGraph,
-        RdfGraph,
-    )
-
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "MemgraphGraph": "langchain_community.graphs",
-    "NetworkxEntityGraph": "langchain_community.graphs",
-    "Neo4jGraph": "langchain_community.graphs",
-    "NebulaGraph": "langchain_community.graphs",
-    "NeptuneGraph": "langchain_community.graphs",
-    "KuzuGraph": "langchain_community.graphs",
-    "HugeGraph": "langchain_community.graphs",
-    "RdfGraph": "langchain_community.graphs",
-    "ArangoGraph": "langchain_community.graphs",
-    "FalkorDBGraph": "langchain_community.graphs",
-}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ArangoGraph",
-    "FalkorDBGraph",
-    "HugeGraph",
-    "KuzuGraph",
-    "MemgraphGraph",
-    "NebulaGraph",
-    "Neo4jGraph",
-    "NeptuneGraph",
-    "NetworkxEntityGraph",
-    "RdfGraph",
-]

langchain/graphs/arangodb_graph.py

@@ -1,28 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.graphs import ArangoGraph
-    from langchain_community.graphs.arangodb_graph import get_arangodb_client
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "ArangoGraph": "langchain_community.graphs",
-    "get_arangodb_client": "langchain_community.graphs.arangodb_graph",
-}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ArangoGraph",
-    "get_arangodb_client",
-]

langchain/graphs/falkordb_graph.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.graphs import FalkorDBGraph
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"FalkorDBGraph": "langchain_community.graphs"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "FalkorDBGraph",
-]

langchain/graphs/graph_document.py

@@ -1,33 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.graphs.graph_document import (
-        GraphDocument,
-        Node,
-        Relationship,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "Node": "langchain_community.graphs.graph_document",
-    "Relationship": "langchain_community.graphs.graph_document",
-    "GraphDocument": "langchain_community.graphs.graph_document",
-}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "GraphDocument",
-    "Node",
-    "Relationship",
-]

langchain/graphs/graph_store.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.graphs.graph_store import GraphStore
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"GraphStore": "langchain_community.graphs.graph_store"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "GraphStore",
-]

langchain/graphs/hugegraph.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.graphs import HugeGraph
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"HugeGraph": "langchain_community.graphs"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "HugeGraph",
-]

langchain/graphs/kuzu_graph.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.graphs import KuzuGraph
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"KuzuGraph": "langchain_community.graphs"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "KuzuGraph",
-]