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

langchain/storage/encoder_backed.py

@@ -1,128 +0,0 @@
-from collections.abc import AsyncIterator, Iterator, Sequence
-from typing import (
-    Any,
-    Callable,
-    Optional,
-    TypeVar,
-    Union,
-)
-
-from langchain_core.stores import BaseStore
-
-K = TypeVar("K")
-V = TypeVar("V")
-
-
-class EncoderBackedStore(BaseStore[K, V]):
-    """Wraps a store with key and value encoders/decoders.
-
-    Examples that uses JSON for encoding/decoding:
-
-    .. code-block:: python
-
-        import json
-
-        def key_encoder(key: int) -> str:
-            return json.dumps(key)
-
-        def value_serializer(value: float) -> str:
-            return json.dumps(value)
-
-        def value_deserializer(serialized_value: str) -> float:
-            return json.loads(serialized_value)
-
-        # Create an instance of the abstract store
-        abstract_store = MyCustomStore()
-
-        # Create an instance of the encoder-backed store
-        store = EncoderBackedStore(
-            store=abstract_store,
-            key_encoder=key_encoder,
-            value_serializer=value_serializer,
-            value_deserializer=value_deserializer
-        )
-
-        # Use the encoder-backed store methods
-        store.mset([(1, 3.14), (2, 2.718)])
-        values = store.mget([1, 2])  # Retrieves [3.14, 2.718]
-        store.mdelete([1, 2])  # Deletes the keys 1 and 2
-
-    """
-
-    def __init__(
-        self,
-        store: BaseStore[str, Any],
-        key_encoder: Callable[[K], str],
-        value_serializer: Callable[[V], bytes],
-        value_deserializer: Callable[[Any], V],
-    ) -> None:
-        """Initialize an EncodedStore."""
-        self.store = store
-        self.key_encoder = key_encoder
-        self.value_serializer = value_serializer
-        self.value_deserializer = value_deserializer
-
-    def mget(self, keys: Sequence[K]) -> list[Optional[V]]:
-        """Get the values associated with the given keys."""
-        encoded_keys: list[str] = [self.key_encoder(key) for key in keys]
-        values = self.store.mget(encoded_keys)
-        return [
-            self.value_deserializer(value) if value is not None else value
-            for value in values
-        ]
-
-    async def amget(self, keys: Sequence[K]) -> list[Optional[V]]:
-        """Get the values associated with the given keys."""
-        encoded_keys: list[str] = [self.key_encoder(key) for key in keys]
-        values = await self.store.amget(encoded_keys)
-        return [
-            self.value_deserializer(value) if value is not None else value
-            for value in values
-        ]
-
-    def mset(self, key_value_pairs: Sequence[tuple[K, V]]) -> None:
-        """Set the values for the given keys."""
-        encoded_pairs = [
-            (self.key_encoder(key), self.value_serializer(value))
-            for key, value in key_value_pairs
-        ]
-        self.store.mset(encoded_pairs)
-
-    async def amset(self, key_value_pairs: Sequence[tuple[K, V]]) -> None:
-        """Set the values for the given keys."""
-        encoded_pairs = [
-            (self.key_encoder(key), self.value_serializer(value))
-            for key, value in key_value_pairs
-        ]
-        await self.store.amset(encoded_pairs)
-
-    def mdelete(self, keys: Sequence[K]) -> None:
-        """Delete the given keys and their associated values."""
-        encoded_keys = [self.key_encoder(key) for key in keys]
-        self.store.mdelete(encoded_keys)
-
-    async def amdelete(self, keys: Sequence[K]) -> None:
-        """Delete the given keys and their associated values."""
-        encoded_keys = [self.key_encoder(key) for key in keys]
-        await self.store.amdelete(encoded_keys)
-
-    def yield_keys(
-        self,
-        *,
-        prefix: Optional[str] = None,
-    ) -> Union[Iterator[K], Iterator[str]]:
-        """Get an iterator over keys that match the given prefix."""
-        # For the time being this does not return K, but str
-        # it's for debugging purposes. Should fix this.
-        yield from self.store.yield_keys(prefix=prefix)
-
-    async def ayield_keys(
-        self,
-        *,
-        prefix: Optional[str] = None,
-    ) -> Union[AsyncIterator[K], AsyncIterator[str]]:
-        """Get an iterator over keys that match the given prefix."""
-        # For the time being this does not return K, but str
-        # it's for debugging purposes. Should fix this.
-        async for key in self.store.ayield_keys(prefix=prefix):
-            yield key

langchain/storage/exceptions.py

@@ -1,3 +0,0 @@
-from langchain_core.stores import InvalidKeyException
-
-__all__ = ["InvalidKeyException"]

langchain/storage/file_system.py

@@ -1,176 +0,0 @@
-import os
-import re
-import time
-from collections.abc import Iterator, Sequence
-from pathlib import Path
-from typing import Optional, Union
-
-from langchain_core.stores import ByteStore
-
-from langchain.storage.exceptions import InvalidKeyException
-
-
-class LocalFileStore(ByteStore):
-    """BaseStore interface that works on the local file system.
-
-    Examples:
-        Create a LocalFileStore instance and perform operations on it:
-
-        .. code-block:: python
-
-            from langchain.storage import LocalFileStore
-
-            # Instantiate the LocalFileStore with the root path
-            file_store = LocalFileStore("/path/to/root")
-
-            # Set values for keys
-            file_store.mset([("key1", b"value1"), ("key2", b"value2")])
-
-            # Get values for keys
-            values = file_store.mget(["key1", "key2"])  # Returns [b"value1", b"value2"]
-
-            # Delete keys
-            file_store.mdelete(["key1"])
-
-            # Iterate over keys
-            for key in file_store.yield_keys():
-                print(key)  # noqa: T201
-
-    """
-
-    def __init__(
-        self,
-        root_path: Union[str, Path],
-        *,
-        chmod_file: Optional[int] = None,
-        chmod_dir: Optional[int] = None,
-        update_atime: bool = False,
-    ) -> None:
-        """Implement the BaseStore interface for the local file system.
-
-        Args:
-            root_path (Union[str, Path]): The root path of the file store. All keys are
-                interpreted as paths relative to this root.
-            chmod_file: (optional, defaults to `None`) If specified, sets permissions
-                for newly created files, overriding the current `umask` if needed.
-            chmod_dir: (optional, defaults to `None`) If specified, sets permissions
-                for newly created dirs, overriding the current `umask` if needed.
-            update_atime: (optional, defaults to `False`) If `True`, updates the
-                filesystem access time (but not the modified time) when a file is read.
-                This allows MRU/LRU cache policies to be implemented for filesystems
-                where access time updates are disabled.
-        """
-        self.root_path = Path(root_path).absolute()
-        self.chmod_file = chmod_file
-        self.chmod_dir = chmod_dir
-        self.update_atime = update_atime
-
-    def _get_full_path(self, key: str) -> Path:
-        """Get the full path for a given key relative to the root path.
-
-        Args:
-            key (str): The key relative to the root path.
-
-        Returns:
-            Path: The full path for the given key.
-        """
-        if not re.match(r"^[a-zA-Z0-9_.\-/]+$", key):
-            msg = f"Invalid characters in key: {key}"
-            raise InvalidKeyException(msg)
-        full_path = (self.root_path / key).resolve()
-        root_path = self.root_path.resolve()
-        common_path = os.path.commonpath([root_path, full_path])
-        if common_path != str(root_path):
-            msg = (
-                f"Invalid key: {key}. Key should be relative to the full path. "
-                f"{root_path} vs. {common_path} and full path of {full_path}"
-            )
-            raise InvalidKeyException(msg)
-
-        return full_path
-
-    def _mkdir_for_store(self, dir_path: Path) -> None:
-        """Makes a store directory path (including parents) with specified permissions
-
-        This is needed because `Path.mkdir()` is restricted by the current `umask`,
-        whereas the explicit `os.chmod()` used here is not.
-
-        Args:
-            dir_path: (Path) The store directory to make
-
-        Returns:
-            None
-        """
-        if not dir_path.exists():
-            self._mkdir_for_store(dir_path.parent)
-            dir_path.mkdir(exist_ok=True)
-            if self.chmod_dir is not None:
-                dir_path.chmod(self.chmod_dir)
-
-    def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
-        """Get the values associated with the given keys.
-
-        Args:
-            keys: A sequence of keys.
-
-        Returns:
-            A sequence of optional values associated with the keys.
-            If a key is not found, the corresponding value will be None.
-        """
-        values: list[Optional[bytes]] = []
-        for key in keys:
-            full_path = self._get_full_path(key)
-            if full_path.exists():
-                value = full_path.read_bytes()
-                values.append(value)
-                if self.update_atime:
-                    # update access time only; preserve modified time
-                    os.utime(full_path, (time.time(), full_path.stat().st_mtime))
-            else:
-                values.append(None)
-        return values
-
-    def mset(self, key_value_pairs: Sequence[tuple[str, bytes]]) -> None:
-        """Set the values for the given keys.
-
-        Args:
-            key_value_pairs: A sequence of key-value pairs.
-
-        Returns:
-            None
-        """
-        for key, value in key_value_pairs:
-            full_path = self._get_full_path(key)
-            self._mkdir_for_store(full_path.parent)
-            full_path.write_bytes(value)
-            if self.chmod_file is not None:
-                full_path.chmod(self.chmod_file)
-
-    def mdelete(self, keys: Sequence[str]) -> None:
-        """Delete the given keys and their associated values.
-
-        Args:
-            keys (Sequence[str]): A sequence of keys to delete.
-
-        Returns:
-            None
-        """
-        for key in keys:
-            full_path = self._get_full_path(key)
-            if full_path.exists():
-                full_path.unlink()
-
-    def yield_keys(self, prefix: Optional[str] = None) -> Iterator[str]:
-        """Get an iterator over keys that match the given prefix.
-
-        Args:
-            prefix (Optional[str]): The prefix to match.
-
-        Returns:
-            Iterator[str]: An iterator over keys that match the given prefix.
-        """
-        prefix_path = self._get_full_path(prefix) if prefix else self.root_path
-        for file in prefix_path.rglob("*"):
-            if file.is_file():
-                relative_path = file.relative_to(self.root_path)
-                yield str(relative_path)

langchain/storage/in_memory.py

@@ -1,13 +0,0 @@
-"""In memory store that is not thread safe and has no eviction policy.
-
-This is a simple implementation of the BaseStore using a dictionary that is useful
-primarily for unit testing purposes.
-"""
-
-from langchain_core.stores import InMemoryBaseStore, InMemoryByteStore, InMemoryStore
-
-__all__ = [
-    "InMemoryBaseStore",
-    "InMemoryByteStore",
-    "InMemoryStore",
-]

langchain/storage/redis.py

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

langchain/storage/upstash_redis.py

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

langchain/text_splitter.py

@@ -1,50 +0,0 @@
-"""Kept for backwards compatibility."""
-
-from langchain_text_splitters import (
-    Language,
-    RecursiveCharacterTextSplitter,
-    TextSplitter,
-    Tokenizer,
-    TokenTextSplitter,
-)
-from langchain_text_splitters.base import split_text_on_tokens
-from langchain_text_splitters.character import CharacterTextSplitter
-from langchain_text_splitters.html import ElementType, HTMLHeaderTextSplitter
-from langchain_text_splitters.json import RecursiveJsonSplitter
-from langchain_text_splitters.konlpy import KonlpyTextSplitter
-from langchain_text_splitters.latex import LatexTextSplitter
-from langchain_text_splitters.markdown import (
-    HeaderType,
-    LineType,
-    MarkdownHeaderTextSplitter,
-    MarkdownTextSplitter,
-)
-from langchain_text_splitters.nltk import NLTKTextSplitter
-from langchain_text_splitters.python import PythonCodeTextSplitter
-from langchain_text_splitters.sentence_transformers import (
-    SentenceTransformersTokenTextSplitter,
-)
-from langchain_text_splitters.spacy import SpacyTextSplitter
-
-__all__ = [
-    "CharacterTextSplitter",
-    "ElementType",
-    "HTMLHeaderTextSplitter",
-    "HeaderType",
-    "KonlpyTextSplitter",
-    "Language",
-    "LatexTextSplitter",
-    "LineType",
-    "MarkdownHeaderTextSplitter",
-    "MarkdownTextSplitter",
-    "NLTKTextSplitter",
-    "PythonCodeTextSplitter",
-    "RecursiveCharacterTextSplitter",
-    "RecursiveJsonSplitter",
-    "SentenceTransformersTokenTextSplitter",
-    "SpacyTextSplitter",
-    "TextSplitter",
-    "TokenTextSplitter",
-    "Tokenizer",
-    "split_text_on_tokens",
-]

langchain/tools/ainetwork/app.py

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

langchain/tools/ainetwork/base.py

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

langchain/tools/ainetwork/owner.py

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

langchain/tools/ainetwork/rule.py

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

langchain/tools/ainetwork/transfer.py

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

langchain/tools/ainetwork/value.py

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

langchain/tools/amadeus/__init__.py

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

langchain/tools/amadeus/base.py

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