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

langchain/llms/volcengine_maas.py

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

langchain/llms/watsonxllm.py

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

langchain/llms/writer.py

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

langchain/llms/xinference.py

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

langchain/llms/yandex.py

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

langchain/load/__init__.py

@@ -1,11 +0,0 @@
-"""Serialization and deserialization."""
-
-from langchain_core.load.dump import dumpd, dumps
-from langchain_core.load.load import load, loads
-
-__all__ = [
-    "dumpd",
-    "dumps",
-    "load",
-    "loads",
-]

langchain/load/dump.py

@@ -1,3 +0,0 @@
-from langchain_core.load.dump import default, dumpd, dumps
-
-__all__ = ["default", "dumpd", "dumps"]

langchain/load/load.py

@@ -1,3 +0,0 @@
-from langchain_core.load.load import Reviver, load, loads
-
-__all__ = ["Reviver", "load", "loads"]

langchain/load/serializable.py

@@ -1,19 +0,0 @@
-from langchain_core.load.serializable import (
-    BaseSerialized,
-    Serializable,
-    SerializedConstructor,
-    SerializedNotImplemented,
-    SerializedSecret,
-    to_json_not_implemented,
-    try_neq_default,
-)
-
-__all__ = [
-    "BaseSerialized",
-    "Serializable",
-    "SerializedConstructor",
-    "SerializedNotImplemented",
-    "SerializedSecret",
-    "to_json_not_implemented",
-    "try_neq_default",
-]

langchain/memory/__init__.py

@@ -1,153 +0,0 @@
-"""**Memory** maintains Chain state, incorporating context from past runs.
-
-**Class hierarchy for Memory:**
-
-.. code-block::
-
-    BaseMemory --> BaseChatMemory --> <name>Memory  # Examples: ZepMemory, MotorheadMemory
-
-**Main helpers:**
-
-.. code-block::
-
-    BaseChatMessageHistory
-
-**Chat Message History** stores the chat message history in different stores.
-
-**Class hierarchy for ChatMessageHistory:**
-
-.. code-block::
-
-    BaseChatMessageHistory --> <name>ChatMessageHistory  # Example: ZepChatMessageHistory
-
-**Main helpers:**
-
-.. code-block::
-
-    AIMessage, BaseMessage, HumanMessage
-"""  # noqa: E501
-
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-from langchain.memory.buffer import (
-    ConversationBufferMemory,
-    ConversationStringBufferMemory,
-)
-from langchain.memory.buffer_window import ConversationBufferWindowMemory
-from langchain.memory.combined import CombinedMemory
-from langchain.memory.entity import (
-    ConversationEntityMemory,
-    InMemoryEntityStore,
-    RedisEntityStore,
-    SQLiteEntityStore,
-    UpstashRedisEntityStore,
-)
-from langchain.memory.readonly import ReadOnlySharedMemory
-from langchain.memory.simple import SimpleMemory
-from langchain.memory.summary import ConversationSummaryMemory
-from langchain.memory.summary_buffer import ConversationSummaryBufferMemory
-from langchain.memory.token_buffer import ConversationTokenBufferMemory
-from langchain.memory.vectorstore import VectorStoreRetrieverMemory
-from langchain.memory.vectorstore_token_buffer_memory import (
-    ConversationVectorStoreTokenBufferMemory,  # avoid circular import
-)
-
-if TYPE_CHECKING:
-    from langchain_community.chat_message_histories import (
-        AstraDBChatMessageHistory,
-        CassandraChatMessageHistory,
-        ChatMessageHistory,
-        CosmosDBChatMessageHistory,
-        DynamoDBChatMessageHistory,
-        ElasticsearchChatMessageHistory,
-        FileChatMessageHistory,
-        MomentoChatMessageHistory,
-        MongoDBChatMessageHistory,
-        PostgresChatMessageHistory,
-        RedisChatMessageHistory,
-        SingleStoreDBChatMessageHistory,
-        SQLChatMessageHistory,
-        StreamlitChatMessageHistory,
-        UpstashRedisChatMessageHistory,
-        XataChatMessageHistory,
-        ZepChatMessageHistory,
-    )
-    from langchain_community.memory.kg import ConversationKGMemory
-    from langchain_community.memory.motorhead_memory import MotorheadMemory
-    from langchain_community.memory.zep_memory import ZepMemory
-
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "MotorheadMemory": "langchain_community.memory.motorhead_memory",
-    "ConversationKGMemory": "langchain_community.memory.kg",
-    "ZepMemory": "langchain_community.memory.zep_memory",
-    "AstraDBChatMessageHistory": "langchain_community.chat_message_histories",
-    "CassandraChatMessageHistory": "langchain_community.chat_message_histories",
-    "ChatMessageHistory": "langchain_community.chat_message_histories",
-    "CosmosDBChatMessageHistory": "langchain_community.chat_message_histories",
-    "DynamoDBChatMessageHistory": "langchain_community.chat_message_histories",
-    "ElasticsearchChatMessageHistory": "langchain_community.chat_message_histories",
-    "FileChatMessageHistory": "langchain_community.chat_message_histories",
-    "MomentoChatMessageHistory": "langchain_community.chat_message_histories",
-    "MongoDBChatMessageHistory": "langchain_community.chat_message_histories",
-    "PostgresChatMessageHistory": "langchain_community.chat_message_histories",
-    "RedisChatMessageHistory": "langchain_community.chat_message_histories",
-    "SingleStoreDBChatMessageHistory": "langchain_community.chat_message_histories",
-    "SQLChatMessageHistory": "langchain_community.chat_message_histories",
-    "StreamlitChatMessageHistory": "langchain_community.chat_message_histories",
-    "UpstashRedisChatMessageHistory": "langchain_community.chat_message_histories",
-    "XataChatMessageHistory": "langchain_community.chat_message_histories",
-    "ZepChatMessageHistory": "langchain_community.chat_message_histories",
-}
-
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "AstraDBChatMessageHistory",
-    "CassandraChatMessageHistory",
-    "ChatMessageHistory",
-    "CombinedMemory",
-    "ConversationBufferMemory",
-    "ConversationBufferWindowMemory",
-    "ConversationEntityMemory",
-    "ConversationKGMemory",
-    "ConversationStringBufferMemory",
-    "ConversationSummaryBufferMemory",
-    "ConversationSummaryMemory",
-    "ConversationTokenBufferMemory",
-    "ConversationVectorStoreTokenBufferMemory",
-    "CosmosDBChatMessageHistory",
-    "DynamoDBChatMessageHistory",
-    "ElasticsearchChatMessageHistory",
-    "FileChatMessageHistory",
-    "InMemoryEntityStore",
-    "MomentoChatMessageHistory",
-    "MongoDBChatMessageHistory",
-    "MotorheadMemory",
-    "PostgresChatMessageHistory",
-    "ReadOnlySharedMemory",
-    "RedisChatMessageHistory",
-    "RedisEntityStore",
-    "SQLChatMessageHistory",
-    "SQLiteEntityStore",
-    "SimpleMemory",
-    "SingleStoreDBChatMessageHistory",
-    "StreamlitChatMessageHistory",
-    "UpstashRedisChatMessageHistory",
-    "UpstashRedisEntityStore",
-    "VectorStoreRetrieverMemory",
-    "XataChatMessageHistory",
-    "ZepChatMessageHistory",
-    "ZepMemory",
-]

langchain/memory/buffer.py

@@ -1,178 +0,0 @@
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.memory import BaseMemory
-from langchain_core.messages import BaseMessage, get_buffer_string
-from langchain_core.utils import pre_init
-from typing_extensions import override
-
-from langchain.memory.chat_memory import BaseChatMemory
-from langchain.memory.utils import get_prompt_input_key
-
-
-@deprecated(
-    since="0.3.1",
-    removal="1.0.0",
-    message=(
-        "Please see the migration guide at: "
-        "https://python.langchain.com/docs/versions/migrating_memory/"
-    ),
-)
-class ConversationBufferMemory(BaseChatMemory):
-    """A basic memory implementation that simply stores the conversation history.
-
-    This stores the entire conversation history in memory without any
-    additional processing.
-
-    Note that additional processing may be required in some situations when the
-    conversation history is too large to fit in the context window of the model.
-    """
-
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    memory_key: str = "history"  #: :meta private:
-
-    @property
-    def buffer(self) -> Any:
-        """String buffer of memory."""
-        return self.buffer_as_messages if self.return_messages else self.buffer_as_str
-
-    async def abuffer(self) -> Any:
-        """String buffer of memory."""
-        return (
-            await self.abuffer_as_messages()
-            if self.return_messages
-            else await self.abuffer_as_str()
-        )
-
-    def _buffer_as_str(self, messages: list[BaseMessage]) -> str:
-        return get_buffer_string(
-            messages,
-            human_prefix=self.human_prefix,
-            ai_prefix=self.ai_prefix,
-        )
-
-    @property
-    def buffer_as_str(self) -> str:
-        """Exposes the buffer as a string in case return_messages is True."""
-        return self._buffer_as_str(self.chat_memory.messages)
-
-    async def abuffer_as_str(self) -> str:
-        """Exposes the buffer as a string in case return_messages is True."""
-        messages = await self.chat_memory.aget_messages()
-        return self._buffer_as_str(messages)
-
-    @property
-    def buffer_as_messages(self) -> list[BaseMessage]:
-        """Exposes the buffer as a list of messages in case return_messages is False."""
-        return self.chat_memory.messages
-
-    async def abuffer_as_messages(self) -> list[BaseMessage]:
-        """Exposes the buffer as a list of messages in case return_messages is False."""
-        return await self.chat_memory.aget_messages()
-
-    @property
-    def memory_variables(self) -> list[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    @override
-    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Return history buffer."""
-        return {self.memory_key: self.buffer}
-
-    @override
-    async def aload_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Return key-value pairs given the text input to the chain."""
-        buffer = await self.abuffer()
-        return {self.memory_key: buffer}
-
-
-@deprecated(
-    since="0.3.1",
-    removal="1.0.0",
-    message=(
-        "Please see the migration guide at: "
-        "https://python.langchain.com/docs/versions/migrating_memory/"
-    ),
-)
-class ConversationStringBufferMemory(BaseMemory):
-    """A basic memory implementation that simply stores the conversation history.
-
-    This stores the entire conversation history in memory without any
-    additional processing.
-
-    Equivalent to ConversationBufferMemory but tailored more specifically
-    for string-based conversations rather than chat models.
-
-    Note that additional processing may be required in some situations when the
-    conversation history is too large to fit in the context window of the model.
-    """
-
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    """Prefix to use for AI generated responses."""
-    buffer: str = ""
-    output_key: Optional[str] = None
-    input_key: Optional[str] = None
-    memory_key: str = "history"  #: :meta private:
-
-    @pre_init
-    def validate_chains(cls, values: dict) -> dict:
-        """Validate that return messages is not True."""
-        if values.get("return_messages", False):
-            msg = "return_messages must be False for ConversationStringBufferMemory"
-            raise ValueError(msg)
-        return values
-
-    @property
-    def memory_variables(self) -> list[str]:
-        """Will always return list of memory variables.
-        :meta private:
-        """
-        return [self.memory_key]
-
-    @override
-    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, str]:
-        """Return history buffer."""
-        return {self.memory_key: self.buffer}
-
-    async def aload_memory_variables(self, inputs: dict[str, Any]) -> dict[str, str]:
-        """Return history buffer."""
-        return self.load_memory_variables(inputs)
-
-    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        if self.input_key is None:
-            prompt_input_key = get_prompt_input_key(inputs, self.memory_variables)
-        else:
-            prompt_input_key = self.input_key
-        if self.output_key is None:
-            if len(outputs) != 1:
-                msg = f"One output key expected, got {outputs.keys()}"
-                raise ValueError(msg)
-            output_key = next(iter(outputs.keys()))
-        else:
-            output_key = self.output_key
-        human = f"{self.human_prefix}: " + inputs[prompt_input_key]
-        ai = f"{self.ai_prefix}: " + outputs[output_key]
-        self.buffer += f"\n{human}\n{ai}"
-
-    async def asave_context(
-        self,
-        inputs: dict[str, Any],
-        outputs: dict[str, str],
-    ) -> None:
-        """Save context from this conversation to buffer."""
-        return self.save_context(inputs, outputs)
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        self.buffer = ""
-
-    @override
-    async def aclear(self) -> None:
-        self.clear()

langchain/memory/buffer_window.py

@@ -1,62 +0,0 @@
-from typing import Any, Union
-
-from langchain_core._api import deprecated
-from langchain_core.messages import BaseMessage, get_buffer_string
-from typing_extensions import override
-
-from langchain.memory.chat_memory import BaseChatMemory
-
-
-@deprecated(
-    since="0.3.1",
-    removal="1.0.0",
-    message=(
-        "Please see the migration guide at: "
-        "https://python.langchain.com/docs/versions/migrating_memory/"
-    ),
-)
-class ConversationBufferWindowMemory(BaseChatMemory):
-    """Use to keep track of the last k turns of a conversation.
-
-    If the number of messages in the conversation is more than the maximum number
-    of messages to keep, the oldest messages are dropped.
-    """
-
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    memory_key: str = "history"  #: :meta private:
-    k: int = 5
-    """Number of messages to store in buffer."""
-
-    @property
-    def buffer(self) -> Union[str, list[BaseMessage]]:
-        """String buffer of memory."""
-        return self.buffer_as_messages if self.return_messages else self.buffer_as_str
-
-    @property
-    def buffer_as_str(self) -> str:
-        """Exposes the buffer as a string in case return_messages is False."""
-        messages = self.chat_memory.messages[-self.k * 2 :] if self.k > 0 else []
-        return get_buffer_string(
-            messages,
-            human_prefix=self.human_prefix,
-            ai_prefix=self.ai_prefix,
-        )
-
-    @property
-    def buffer_as_messages(self) -> list[BaseMessage]:
-        """Exposes the buffer as a list of messages in case return_messages is True."""
-        return self.chat_memory.messages[-self.k * 2 :] if self.k > 0 else []
-
-    @property
-    def memory_variables(self) -> list[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    @override
-    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Return history buffer."""
-        return {self.memory_key: self.buffer}

langchain/memory/chat_memory.py

@@ -1,104 +0,0 @@
-import warnings
-from abc import ABC
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.chat_history import (
-    BaseChatMessageHistory,
-    InMemoryChatMessageHistory,
-)
-from langchain_core.memory import BaseMemory
-from langchain_core.messages import AIMessage, HumanMessage
-from pydantic import Field
-
-from langchain.memory.utils import get_prompt_input_key
-
-
-@deprecated(
-    since="0.3.1",
-    removal="1.0.0",
-    message=(
-        "Please see the migration guide at: "
-        "https://python.langchain.com/docs/versions/migrating_memory/"
-    ),
-)
-class BaseChatMemory(BaseMemory, ABC):
-    """Abstract base class for chat memory.
-
-    **ATTENTION** This abstraction was created prior to when chat models had
-        native tool calling capabilities.
-        It does **NOT** support native tool calling capabilities for chat models and
-        will fail SILENTLY if used with a chat model that has native tool calling.
-
-    DO NOT USE THIS ABSTRACTION FOR NEW CODE.
-    """
-
-    chat_memory: BaseChatMessageHistory = Field(
-        default_factory=InMemoryChatMessageHistory,
-    )
-    output_key: Optional[str] = None
-    input_key: Optional[str] = None
-    return_messages: bool = False
-
-    def _get_input_output(
-        self,
-        inputs: dict[str, Any],
-        outputs: dict[str, str],
-    ) -> tuple[str, str]:
-        if self.input_key is None:
-            prompt_input_key = get_prompt_input_key(inputs, self.memory_variables)
-        else:
-            prompt_input_key = self.input_key
-        if self.output_key is None:
-            if len(outputs) == 1:
-                output_key = next(iter(outputs.keys()))
-            elif "output" in outputs:
-                output_key = "output"
-                warnings.warn(
-                    f"'{self.__class__.__name__}' got multiple output keys:"
-                    f" {outputs.keys()}. The default 'output' key is being used."
-                    f" If this is not desired, please manually set 'output_key'.",
-                    stacklevel=3,
-                )
-            else:
-                msg = (
-                    f"Got multiple output keys: {outputs.keys()}, cannot "
-                    f"determine which to store in memory. Please set the "
-                    f"'output_key' explicitly."
-                )
-                raise ValueError(msg)
-        else:
-            output_key = self.output_key
-        return inputs[prompt_input_key], outputs[output_key]
-
-    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        input_str, output_str = self._get_input_output(inputs, outputs)
-        self.chat_memory.add_messages(
-            [
-                HumanMessage(content=input_str),
-                AIMessage(content=output_str),
-            ],
-        )
-
-    async def asave_context(
-        self,
-        inputs: dict[str, Any],
-        outputs: dict[str, str],
-    ) -> None:
-        """Save context from this conversation to buffer."""
-        input_str, output_str = self._get_input_output(inputs, outputs)
-        await self.chat_memory.aadd_messages(
-            [
-                HumanMessage(content=input_str),
-                AIMessage(content=output_str),
-            ],
-        )
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        self.chat_memory.clear()
-
-    async def aclear(self) -> None:
-        """Clear memory contents."""
-        await self.chat_memory.aclear()