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

langchain/embeddings/__init__.py

@@ -1,226 +1,10 @@
-"""**Embedding models**  are wrappers around embedding models
-from different APIs and services.
+from langchain_core.embeddings import Embeddings
 
-Embedding models can be LLMs or not.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    Embeddings --> <name>Embeddings  # Examples: OpenAIEmbeddings, HuggingFaceEmbeddings
-"""
-
-import logging
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
 from langchain.embeddings.base import init_embeddings
 from langchain.embeddings.cache import CacheBackedEmbeddings
 
-if TYPE_CHECKING:
-    from langchain_community.embeddings import (
-        AlephAlphaAsymmetricSemanticEmbedding,
-        AlephAlphaSymmetricSemanticEmbedding,
-        AwaEmbeddings,
-        AzureOpenAIEmbeddings,
-        BedrockEmbeddings,
-        BookendEmbeddings,
-        ClarifaiEmbeddings,
-        CohereEmbeddings,
-        DashScopeEmbeddings,
-        DatabricksEmbeddings,
-        DeepInfraEmbeddings,
-        DeterministicFakeEmbedding,
-        EdenAiEmbeddings,
-        ElasticsearchEmbeddings,
-        EmbaasEmbeddings,
-        ErnieEmbeddings,
-        FakeEmbeddings,
-        FastEmbedEmbeddings,
-        GooglePalmEmbeddings,
-        GPT4AllEmbeddings,
-        GradientEmbeddings,
-        HuggingFaceBgeEmbeddings,
-        HuggingFaceEmbeddings,
-        HuggingFaceHubEmbeddings,
-        HuggingFaceInferenceAPIEmbeddings,
-        HuggingFaceInstructEmbeddings,
-        InfinityEmbeddings,
-        JavelinAIGatewayEmbeddings,
-        JinaEmbeddings,
-        JohnSnowLabsEmbeddings,
-        LlamaCppEmbeddings,
-        LocalAIEmbeddings,
-        MiniMaxEmbeddings,
-        MlflowAIGatewayEmbeddings,
-        MlflowEmbeddings,
-        ModelScopeEmbeddings,
-        MosaicMLInstructorEmbeddings,
-        NLPCloudEmbeddings,
-        OctoAIEmbeddings,
-        OllamaEmbeddings,
-        OpenAIEmbeddings,
-        OpenVINOEmbeddings,
-        QianfanEmbeddingsEndpoint,
-        SagemakerEndpointEmbeddings,
-        SelfHostedEmbeddings,
-        SelfHostedHuggingFaceEmbeddings,
-        SelfHostedHuggingFaceInstructEmbeddings,
-        SentenceTransformerEmbeddings,
-        SpacyEmbeddings,
-        TensorflowHubEmbeddings,
-        VertexAIEmbeddings,
-        VoyageEmbeddings,
-        XinferenceEmbeddings,
-    )
-
-
-logger = logging.getLogger(__name__)
-
-
-# TODO: this is in here to maintain backwards compatibility
-class HypotheticalDocumentEmbedder:
-    def __init__(self, *args: Any, **kwargs: Any):
-        logger.warning(
-            "Using a deprecated class. Please use "
-            "`from langchain.chains import HypotheticalDocumentEmbedder` instead",
-        )
-        from langchain.chains.hyde.base import HypotheticalDocumentEmbedder as H
-
-        return H(*args, **kwargs)  # type: ignore[return-value] # noqa: PLE0101
-
-    @classmethod
-    def from_llm(cls, *args: Any, **kwargs: Any) -> Any:
-        logger.warning(
-            "Using a deprecated class. Please use "
-            "`from langchain.chains import HypotheticalDocumentEmbedder` instead",
-        )
-        from langchain.chains.hyde.base import HypotheticalDocumentEmbedder as H
-
-        return H.from_llm(*args, **kwargs)
-
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "AlephAlphaAsymmetricSemanticEmbedding": "langchain_community.embeddings",
-    "AlephAlphaSymmetricSemanticEmbedding": "langchain_community.embeddings",
-    "AwaEmbeddings": "langchain_community.embeddings",
-    "AzureOpenAIEmbeddings": "langchain_community.embeddings",
-    "BedrockEmbeddings": "langchain_community.embeddings",
-    "BookendEmbeddings": "langchain_community.embeddings",
-    "ClarifaiEmbeddings": "langchain_community.embeddings",
-    "CohereEmbeddings": "langchain_community.embeddings",
-    "DashScopeEmbeddings": "langchain_community.embeddings",
-    "DatabricksEmbeddings": "langchain_community.embeddings",
-    "DeepInfraEmbeddings": "langchain_community.embeddings",
-    "DeterministicFakeEmbedding": "langchain_community.embeddings",
-    "EdenAiEmbeddings": "langchain_community.embeddings",
-    "ElasticsearchEmbeddings": "langchain_community.embeddings",
-    "EmbaasEmbeddings": "langchain_community.embeddings",
-    "ErnieEmbeddings": "langchain_community.embeddings",
-    "FakeEmbeddings": "langchain_community.embeddings",
-    "FastEmbedEmbeddings": "langchain_community.embeddings",
-    "GooglePalmEmbeddings": "langchain_community.embeddings",
-    "GPT4AllEmbeddings": "langchain_community.embeddings",
-    "GradientEmbeddings": "langchain_community.embeddings",
-    "HuggingFaceBgeEmbeddings": "langchain_community.embeddings",
-    "HuggingFaceEmbeddings": "langchain_community.embeddings",
-    "HuggingFaceHubEmbeddings": "langchain_community.embeddings",
-    "HuggingFaceInferenceAPIEmbeddings": "langchain_community.embeddings",
-    "HuggingFaceInstructEmbeddings": "langchain_community.embeddings",
-    "InfinityEmbeddings": "langchain_community.embeddings",
-    "JavelinAIGatewayEmbeddings": "langchain_community.embeddings",
-    "JinaEmbeddings": "langchain_community.embeddings",
-    "JohnSnowLabsEmbeddings": "langchain_community.embeddings",
-    "LlamaCppEmbeddings": "langchain_community.embeddings",
-    "LocalAIEmbeddings": "langchain_community.embeddings",
-    "MiniMaxEmbeddings": "langchain_community.embeddings",
-    "MlflowAIGatewayEmbeddings": "langchain_community.embeddings",
-    "MlflowEmbeddings": "langchain_community.embeddings",
-    "ModelScopeEmbeddings": "langchain_community.embeddings",
-    "MosaicMLInstructorEmbeddings": "langchain_community.embeddings",
-    "NLPCloudEmbeddings": "langchain_community.embeddings",
-    "OctoAIEmbeddings": "langchain_community.embeddings",
-    "OllamaEmbeddings": "langchain_community.embeddings",
-    "OpenAIEmbeddings": "langchain_community.embeddings",
-    "OpenVINOEmbeddings": "langchain_community.embeddings",
-    "QianfanEmbeddingsEndpoint": "langchain_community.embeddings",
-    "SagemakerEndpointEmbeddings": "langchain_community.embeddings",
-    "SelfHostedEmbeddings": "langchain_community.embeddings",
-    "SelfHostedHuggingFaceEmbeddings": "langchain_community.embeddings",
-    "SelfHostedHuggingFaceInstructEmbeddings": "langchain_community.embeddings",
-    "SentenceTransformerEmbeddings": "langchain_community.embeddings",
-    "SpacyEmbeddings": "langchain_community.embeddings",
-    "TensorflowHubEmbeddings": "langchain_community.embeddings",
-    "VertexAIEmbeddings": "langchain_community.embeddings",
-    "VoyageEmbeddings": "langchain_community.embeddings",
-    "XinferenceEmbeddings": "langchain_community.embeddings",
-}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
 __all__ = [
-    "AlephAlphaAsymmetricSemanticEmbedding",
-    "AlephAlphaSymmetricSemanticEmbedding",
-    "AwaEmbeddings",
-    "AzureOpenAIEmbeddings",
-    "BedrockEmbeddings",
-    "BookendEmbeddings",
     "CacheBackedEmbeddings",
-    "ClarifaiEmbeddings",
-    "CohereEmbeddings",
-    "DashScopeEmbeddings",
-    "DatabricksEmbeddings",
-    "DeepInfraEmbeddings",
-    "DeterministicFakeEmbedding",
-    "EdenAiEmbeddings",
-    "ElasticsearchEmbeddings",
-    "EmbaasEmbeddings",
-    "ErnieEmbeddings",
-    "FakeEmbeddings",
-    "FastEmbedEmbeddings",
-    "GPT4AllEmbeddings",
-    "GooglePalmEmbeddings",
-    "GradientEmbeddings",
-    "HuggingFaceBgeEmbeddings",
-    "HuggingFaceEmbeddings",
-    "HuggingFaceHubEmbeddings",
-    "HuggingFaceInferenceAPIEmbeddings",
-    "HuggingFaceInstructEmbeddings",
-    "InfinityEmbeddings",
-    "JavelinAIGatewayEmbeddings",
-    "JinaEmbeddings",
-    "JohnSnowLabsEmbeddings",
-    "LlamaCppEmbeddings",
-    "LocalAIEmbeddings",
-    "MiniMaxEmbeddings",
-    "MlflowAIGatewayEmbeddings",
-    "MlflowEmbeddings",
-    "ModelScopeEmbeddings",
-    "MosaicMLInstructorEmbeddings",
-    "NLPCloudEmbeddings",
-    "OctoAIEmbeddings",
-    "OllamaEmbeddings",
-    "OpenAIEmbeddings",
-    "OpenVINOEmbeddings",
-    "QianfanEmbeddingsEndpoint",
-    "SagemakerEndpointEmbeddings",
-    "SelfHostedEmbeddings",
-    "SelfHostedHuggingFaceEmbeddings",
-    "SelfHostedHuggingFaceInstructEmbeddings",
-    "SentenceTransformerEmbeddings",
-    "SpacyEmbeddings",
-    "TensorflowHubEmbeddings",
-    "VertexAIEmbeddings",
-    "VoyageEmbeddings",
-    "XinferenceEmbeddings",
+    "Embeddings",
     "init_embeddings",
 ]

langchain/embeddings/base.py

@@ -1,6 +1,6 @@
 import functools
 from importlib import util
-from typing import Any, Optional, Union
+from typing import Any, Union
 
 from langchain_core.embeddings import Embeddings
 from langchain_core.runnables import Runnable
@@ -19,9 +19,7 @@ _SUPPORTED_PROVIDERS = {
 
 def _get_provider_list() -> str:
     """Get formatted list of providers and their packages."""
-    return "\n".join(
-        f"  - {p}: {pkg.replace('_', '-')}" for p, pkg in _SUPPORTED_PROVIDERS.items()
-    )
+    return "\n".join(f"  - {p}: {pkg.replace('_', '-')}" for p, pkg in _SUPPORTED_PROVIDERS.items())
 
 
 def _parse_model_string(model_name: str) -> tuple[str, str]:
@@ -82,7 +80,7 @@ def _parse_model_string(model_name: str) -> tuple[str, str]:
 def _infer_model_and_provider(
     model: str,
     *,
-    provider: Optional[str] = None,
+    provider: str | None = None,
 ) -> tuple[str, str]:
     if not model.strip():
         msg = "Model name cannot be empty"
@@ -117,17 +115,14 @@ def _infer_model_and_provider(
 def _check_pkg(pkg: str) -> None:
     """Check if a package is installed."""
     if not util.find_spec(pkg):
-        msg = (
-            f"Could not import {pkg} python package. "
-            f"Please install it with `pip install {pkg}`"
-        )
+        msg = f"Could not import {pkg} python package. Please install it with `pip install {pkg}`"
         raise ImportError(msg)
 
 
 def init_embeddings(
     model: str,
     *,
-    provider: Optional[str] = None,
+    provider: str | None = None,
     **kwargs: Any,
 ) -> Union[Embeddings, Runnable[Any, list[float]]]:
     """Initialize an embeddings model from a model name and optional provider.
@@ -182,9 +177,7 @@ def init_embeddings(
     """
     if not model:
         providers = _SUPPORTED_PROVIDERS.keys()
-        msg = (
-            f"Must specify model name. Supported providers are: {', '.join(providers)}"
-        )
+        msg = f"Must specify model name. Supported providers are: {', '.join(providers)}"
         raise ValueError(msg)
 
     provider, model_name = _infer_model_and_provider(model, provider=provider)

langchain/embeddings/cache.py

@@ -13,15 +13,18 @@ import hashlib
 import json
 import uuid
 import warnings
-from collections.abc import Sequence
-from typing import Callable, Literal, Optional, Union, cast
+from typing import TYPE_CHECKING, Literal, Union, cast
 
 from langchain_core.embeddings import Embeddings
-from langchain_core.stores import BaseStore, ByteStore
 from langchain_core.utils.iter import batch_iterate
 
 from langchain.storage.encoder_backed import EncoderBackedStore
 
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+    from langchain_core.stores import BaseStore, ByteStore
+
 NAMESPACE_UUID = uuid.UUID(int=1985)
 
 
@@ -144,8 +147,8 @@ class CacheBackedEmbeddings(Embeddings):
         underlying_embeddings: Embeddings,
         document_embedding_store: BaseStore[str, list[float]],
         *,
-        batch_size: Optional[int] = None,
-        query_embedding_store: Optional[BaseStore[str, list[float]]] = None,
+        batch_size: int | None = None,
+        query_embedding_store: BaseStore[str, list[float]] | None = None,
     ) -> None:
         """Initialize the embedder.
 
@@ -178,17 +181,15 @@ class CacheBackedEmbeddings(Embeddings):
         vectors: list[Union[list[float], None]] = self.document_embedding_store.mget(
             texts,
         )
-        all_missing_indices: list[int] = [
-            i for i, vector in enumerate(vectors) if vector is None
-        ]
+        all_missing_indices: list[int] = [i for i, vector in enumerate(vectors) if vector is None]
 
         for missing_indices in batch_iterate(self.batch_size, all_missing_indices):
             missing_texts = [texts[i] for i in missing_indices]
             missing_vectors = self.underlying_embeddings.embed_documents(missing_texts)
             self.document_embedding_store.mset(
-                list(zip(missing_texts, missing_vectors)),
+                list(zip(missing_texts, missing_vectors, strict=False)),
             )
-            for index, updated_vector in zip(missing_indices, missing_vectors):
+            for index, updated_vector in zip(missing_indices, missing_vectors, strict=False):
                 vectors[index] = updated_vector
 
         return cast(
@@ -209,12 +210,8 @@ class CacheBackedEmbeddings(Embeddings):
         Returns:
             A list of embeddings for the given texts.
         """
-        vectors: list[
-            Union[list[float], None]
-        ] = await self.document_embedding_store.amget(texts)
-        all_missing_indices: list[int] = [
-            i for i, vector in enumerate(vectors) if vector is None
-        ]
+        vectors: list[Union[list[float], None]] = await self.document_embedding_store.amget(texts)
+        all_missing_indices: list[int] = [i for i, vector in enumerate(vectors) if vector is None]
 
         # batch_iterate supports None batch_size which returns all elements at once
         # as a single batch.
@@ -224,9 +221,9 @@ class CacheBackedEmbeddings(Embeddings):
                 missing_texts,
             )
             await self.document_embedding_store.amset(
-                list(zip(missing_texts, missing_vectors)),
+                list(zip(missing_texts, missing_vectors, strict=False)),
             )
-            for index, updated_vector in zip(missing_indices, missing_vectors):
+            for index, updated_vector in zip(missing_indices, missing_vectors, strict=False):
                 vectors[index] = updated_vector
 
         return cast(
@@ -287,7 +284,7 @@ class CacheBackedEmbeddings(Embeddings):
         document_embedding_cache: ByteStore,
         *,
         namespace: str = "",
-        batch_size: Optional[int] = None,
+        batch_size: int | None = None,
         query_embedding_cache: Union[bool, ByteStore] = False,
         key_encoder: Union[
             Callable[[str], str],

langchain/globals.py

@@ -1,6 +1,8 @@
-"""Global values and configuration that apply to all of LangChain."""
+"""Global values and configuration that apply to all of LangChain.
+
+TODO: will be removed in a future alpha version.
+"""
 
-import warnings
 from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
@@ -14,167 +16,3 @@ if TYPE_CHECKING:
 _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

langchain/storage/__init__.py

@@ -6,52 +6,17 @@ to a simple key-value interface.
 The primary goal of these storages is to support implementation of caching.
 """
 
-from typing import TYPE_CHECKING, Any
-
 from langchain_core.stores import (
     InMemoryByteStore,
     InMemoryStore,
     InvalidKeyException,
 )
 
-from langchain._api import create_importer
-from langchain.storage._lc_store import create_kv_docstore, create_lc_store
 from langchain.storage.encoder_backed import EncoderBackedStore
-from langchain.storage.file_system import LocalFileStore
-
-if TYPE_CHECKING:
-    from langchain_community.storage import (
-        RedisStore,
-        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 = {
-    "RedisStore": "langchain_community.storage",
-    "UpstashRedisByteStore": "langchain_community.storage",
-    "UpstashRedisStore": "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__ = [
     "EncoderBackedStore",
     "InMemoryByteStore",
     "InMemoryStore",
     "InvalidKeyException",
-    "LocalFileStore",
-    "RedisStore",
-    "UpstashRedisByteStore",
-    "UpstashRedisStore",
-    "create_kv_docstore",
-    "create_lc_store",
 ]

langchain/storage/encoder_backed.py

@@ -1,8 +1,6 @@
-from collections.abc import AsyncIterator, Iterator, Sequence
+from collections.abc import AsyncIterator, Callable, Iterator, Sequence
 from typing import (
     Any,
-    Callable,
-    Optional,
     TypeVar,
     Union,
 )
@@ -62,37 +60,29 @@ class EncoderBackedStore(BaseStore[K, V]):
         self.value_serializer = value_serializer
         self.value_deserializer = value_deserializer
 
-    def mget(self, keys: Sequence[K]) -> list[Optional[V]]:
+    def mget(self, keys: Sequence[K]) -> list[V | None]:
         """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
-        ]
+        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]]:
+    async def amget(self, keys: Sequence[K]) -> list[V | None]:
         """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
-        ]
+        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.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
+            (self.key_encoder(key), self.value_serializer(value)) for key, value in key_value_pairs
         ]
         await self.store.amset(encoded_pairs)
 
@@ -109,7 +99,7 @@ class EncoderBackedStore(BaseStore[K, V]):
     def yield_keys(
         self,
         *,
-        prefix: Optional[str] = None,
+        prefix: str | None = 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
@@ -119,7 +109,7 @@ class EncoderBackedStore(BaseStore[K, V]):
     async def ayield_keys(
         self,
         *,
-        prefix: Optional[str] = None,
+        prefix: str | None = 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