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

langchain/memory/summary_buffer.py

@@ -3,6 +3,7 @@ from typing import Any, Union
 from langchain_core._api import deprecated
 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.summary import SummarizerMixin
@@ -46,35 +47,41 @@ class ConversationSummaryBufferMemory(BaseChatMemory, SummarizerMixin):
         """
         return [self.memory_key]
 
+    @override
     def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Return history buffer."""
         buffer = self.chat_memory.messages
         if self.moving_summary_buffer != "":
             first_messages: list[BaseMessage] = [
-                self.summary_message_cls(content=self.moving_summary_buffer)
+                self.summary_message_cls(content=self.moving_summary_buffer),
             ]
             buffer = first_messages + buffer
         if self.return_messages:
             final_buffer: Any = buffer
         else:
             final_buffer = get_buffer_string(
-                buffer, human_prefix=self.human_prefix, ai_prefix=self.ai_prefix
+                buffer,
+                human_prefix=self.human_prefix,
+                ai_prefix=self.ai_prefix,
             )
         return {self.memory_key: final_buffer}
 
+    @override
     async def aload_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Asynchronously return key-value pairs given the text input to the chain."""
         buffer = await self.chat_memory.aget_messages()
         if self.moving_summary_buffer != "":
             first_messages: list[BaseMessage] = [
-                self.summary_message_cls(content=self.moving_summary_buffer)
+                self.summary_message_cls(content=self.moving_summary_buffer),
             ]
             buffer = first_messages + buffer
         if self.return_messages:
             final_buffer: Any = buffer
         else:
             final_buffer = get_buffer_string(
-                buffer, human_prefix=self.human_prefix, ai_prefix=self.ai_prefix
+                buffer,
+                human_prefix=self.human_prefix,
+                ai_prefix=self.ai_prefix,
             )
         return {self.memory_key: final_buffer}
 
@@ -84,10 +91,11 @@ class ConversationSummaryBufferMemory(BaseChatMemory, SummarizerMixin):
         prompt_variables = values["prompt"].input_variables
         expected_keys = {"summary", "new_lines"}
         if expected_keys != set(prompt_variables):
-            raise ValueError(
+            msg = (
                 "Got unexpected prompt input variables. The prompt expects "
                 f"{prompt_variables}, but it should have {expected_keys}."
             )
+            raise ValueError(msg)
         return values
 
     def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
@@ -96,7 +104,9 @@ class ConversationSummaryBufferMemory(BaseChatMemory, SummarizerMixin):
         self.prune()
 
     async def asave_context(
-        self, inputs: dict[str, Any], outputs: dict[str, str]
+        self,
+        inputs: dict[str, Any],
+        outputs: dict[str, str],
     ) -> None:
         """Asynchronously save context from this conversation to buffer."""
         await super().asave_context(inputs, outputs)
@@ -112,7 +122,8 @@ class ConversationSummaryBufferMemory(BaseChatMemory, SummarizerMixin):
                 pruned_memory.append(buffer.pop(0))
                 curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)
             self.moving_summary_buffer = self.predict_new_summary(
-                pruned_memory, self.moving_summary_buffer
+                pruned_memory,
+                self.moving_summary_buffer,
             )
 
     async def aprune(self) -> None:
@@ -125,7 +136,8 @@ class ConversationSummaryBufferMemory(BaseChatMemory, SummarizerMixin):
                 pruned_memory.append(buffer.pop(0))
                 curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)
             self.moving_summary_buffer = await self.apredict_new_summary(
-                pruned_memory, self.moving_summary_buffer
+                pruned_memory,
+                self.moving_summary_buffer,
             )
 
     def clear(self) -> None:

langchain/memory/token_buffer.py

@@ -3,6 +3,7 @@ from typing import Any
 from langchain_core._api import deprecated
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.messages import BaseMessage, get_buffer_string
+from typing_extensions import override
 
 from langchain.memory.chat_memory import BaseChatMemory
 
@@ -55,6 +56,7 @@ class ConversationTokenBufferMemory(BaseChatMemory):
         """
         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/utils.py

@@ -14,7 +14,8 @@ def get_prompt_input_key(inputs: dict[str, Any], memory_variables: list[str]) ->
     """
     # "stop" is a special key that can be passed as input but is not used to
     # format the prompt.
-    prompt_input_keys = list(set(inputs).difference(memory_variables + ["stop"]))
+    prompt_input_keys = list(set(inputs).difference([*memory_variables, "stop"]))
     if len(prompt_input_keys) != 1:
-        raise ValueError(f"One input key expected got {prompt_input_keys}")
+        msg = f"One input key expected got {prompt_input_keys}"
+        raise ValueError(msg)
     return prompt_input_keys[0]

langchain/memory/vectorstore.py

@@ -52,7 +52,8 @@ class VectorStoreRetrieverMemory(BaseMemory):
         return self.input_key
 
     def _documents_to_memory_variables(
-        self, docs: list[Document]
+        self,
+        docs: list[Document],
     ) -> dict[str, Union[list[Document], str]]:
         result: Union[list[Document], str]
         if not self.return_docs:
@@ -62,7 +63,8 @@ class VectorStoreRetrieverMemory(BaseMemory):
         return {self.memory_key: result}
 
     def load_memory_variables(
-        self, inputs: dict[str, Any]
+        self,
+        inputs: dict[str, Any],
     ) -> dict[str, Union[list[Document], str]]:
         """Return history buffer."""
         input_key = self._get_prompt_input_key(inputs)
@@ -71,7 +73,8 @@ class VectorStoreRetrieverMemory(BaseMemory):
         return self._documents_to_memory_variables(docs)
 
     async def aload_memory_variables(
-        self, inputs: dict[str, Any]
+        self,
+        inputs: dict[str, Any],
     ) -> dict[str, Union[list[Document], str]]:
         """Return history buffer."""
         input_key = self._get_prompt_input_key(inputs)
@@ -80,7 +83,9 @@ class VectorStoreRetrieverMemory(BaseMemory):
         return self._documents_to_memory_variables(docs)
 
     def _form_documents(
-        self, inputs: dict[str, Any], outputs: dict[str, str]
+        self,
+        inputs: dict[str, Any],
+        outputs: dict[str, str],
     ) -> list[Document]:
         """Format context from this conversation to buffer."""
         # Each document should only include the current turn, not the chat history
@@ -100,7 +105,9 @@ class VectorStoreRetrieverMemory(BaseMemory):
         self.retriever.add_documents(documents)
 
     async def asave_context(
-        self, inputs: dict[str, Any], outputs: dict[str, str]
+        self,
+        inputs: dict[str, Any],
+        outputs: dict[str, str],
     ) -> None:
         """Save context from this conversation to buffer."""
         documents = self._form_documents(inputs, outputs)

langchain/memory/vectorstore_token_buffer_memory.py

@@ -23,7 +23,7 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter
 DEFAULT_HISTORY_TEMPLATE = """
 Current date and time: {current_time}.
 
-Potentially relevant timestamped excerpts of previous conversations (you 
+Potentially relevant timestamped excerpts of previous conversations (you
 do not need to use these if irrelevant):
 {previous_history}
 
@@ -131,13 +131,13 @@ class ConversationVectorStoreTokenBufferMemory(ConversationTokenBufferMemory):
             previous_history = ""
         current_history = super().load_memory_variables(inputs)
         template = SystemMessagePromptTemplate.from_template(
-            self.previous_history_template
+            self.previous_history_template,
         )
         messages = [
             template.format(
                 previous_history=previous_history,
                 current_time=datetime.now().astimezone().strftime(TIMESTAMP_FORMAT),
-            )
+            ),
         ]
         messages.extend(current_history[self.memory_key])
         return {self.memory_key: messages}
@@ -167,7 +167,7 @@ class ConversationVectorStoreTokenBufferMemory(ConversationTokenBufferMemory):
             self._pop_and_store_interaction(buffer)
 
     def _pop_and_store_interaction(self, buffer: list[BaseMessage]) -> None:
-        input = buffer.pop(0)
+        input_ = buffer.pop(0)
         output = buffer.pop(0)
         timestamp = self._timestamps.pop(0).strftime(TIMESTAMP_FORMAT)
         # Split AI output into smaller chunks to avoid creating documents
@@ -175,7 +175,7 @@ class ConversationVectorStoreTokenBufferMemory(ConversationTokenBufferMemory):
         ai_chunks = self._split_long_ai_text(str(output.content))
         for index, chunk in enumerate(ai_chunks):
             self.memory_retriever.save_context(
-                {"Human": f"<{timestamp}/00> {str(input.content)}"},
+                {"Human": f"<{timestamp}/00> {input_.content!s}"},
                 {"AI": f"<{timestamp}/{index:02}> {chunk}"},
             )
 

langchain/model_laboratory.py

@@ -34,24 +34,26 @@ class ModelLaboratory:
         """
         for chain in chains:
             if not isinstance(chain, Chain):
-                raise ValueError(
+                msg = (
                     "ModelLaboratory should now be initialized with Chains. "
                     "If you want to initialize with LLMs, use the `from_llms` method "
                     "instead (`ModelLaboratory.from_llms(...)`)"
                 )
+                raise ValueError(msg)  # noqa: TRY004
             if len(chain.input_keys) != 1:
-                raise ValueError(
+                msg = (
                     "Currently only support chains with one input variable, "
                     f"got {chain.input_keys}"
                 )
+                raise ValueError(msg)
             if len(chain.output_keys) != 1:
-                raise ValueError(
+                msg = (
                     "Currently only support chains with one output variable, "
                     f"got {chain.output_keys}"
                 )
-        if names is not None:
-            if len(names) != len(chains):
-                raise ValueError("Length of chains does not match length of names.")
+        if names is not None and len(names) != len(chains):
+            msg = "Length of chains does not match length of names."
+            raise ValueError(msg)
         self.chains = chains
         chain_range = [str(i) for i in range(len(self.chains))]
         self.chain_colors = get_color_mapping(chain_range)
@@ -59,7 +61,9 @@ class ModelLaboratory:
 
     @classmethod
     def from_llms(
-        cls, llms: list[BaseLLM], prompt: Optional[PromptTemplate] = None
+        cls,
+        llms: list[BaseLLM],
+        prompt: Optional[PromptTemplate] = None,
     ) -> ModelLaboratory:
         """Initialize the ModelLaboratory with LLMs and an optional prompt.
 
@@ -89,10 +93,7 @@ class ModelLaboratory:
         """
         print(f"\033[1mInput:\033[0m\n{text}\n")  # noqa: T201
         for i, chain in enumerate(self.chains):
-            if self.names is not None:
-                name = self.names[i]
-            else:
-                name = str(chain)
+            name = self.names[i] if self.names is not None else str(chain)
             print_text(name, end="\n")
             output = chain.run(text)
             print_text(output, color=self.chain_colors[str(i)], end="\n\n")

langchain/output_parsers/__init__.py

@@ -49,7 +49,7 @@ if TYPE_CHECKING:
 # Used to consolidate logic for raising deprecation warnings and
 # handling optional imports.
 DEPRECATED_LOOKUP = {
-    "GuardrailsOutputParser": "langchain_community.output_parsers.rail_parser"
+    "GuardrailsOutputParser": "langchain_community.output_parsers.rail_parser",
 }
 
 _import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
@@ -67,12 +67,15 @@ __all__ = [
     "DatetimeOutputParser",
     "EnumOutputParser",
     "GuardrailsOutputParser",
+    "JsonOutputKeyToolsParser",
+    "JsonOutputToolsParser",
     "ListOutputParser",
     "MarkdownListOutputParser",
     "NumberedListOutputParser",
     "OutputFixingParser",
     "PandasDataFrameOutputParser",
     "PydanticOutputParser",
+    "PydanticToolsParser",
     "RegexDictParser",
     "RegexParser",
     "ResponseSchema",
@@ -80,8 +83,5 @@ __all__ = [
     "RetryWithErrorOutputParser",
     "StructuredOutputParser",
     "XMLOutputParser",
-    "JsonOutputToolsParser",
-    "PydanticToolsParser",
-    "JsonOutputKeyToolsParser",
     "YamlOutputParser",
 ]

langchain/output_parsers/boolean.py

@@ -28,22 +28,25 @@ class BooleanOutputParser(BaseOutputParser[bool]):
         }
         if self.true_val.upper() in truthy:
             if self.false_val.upper() in truthy:
-                raise ValueError(
+                msg = (
                     f"Ambiguous response. Both {self.true_val} and {self.false_val} "
                     f"in received: {text}."
                 )
+                raise ValueError(msg)
             return True
-        elif self.false_val.upper() in truthy:
+        if self.false_val.upper() in truthy:
             if self.true_val.upper() in truthy:
-                raise ValueError(
+                msg = (
                     f"Ambiguous response. Both {self.true_val} and {self.false_val} "
                     f"in received: {text}."
                 )
+                raise ValueError(msg)
             return False
-        raise ValueError(
+        msg = (
             f"BooleanOutputParser expected output value to include either "
             f"{self.true_val} or {self.false_val}. Received {text}."
         )
+        raise ValueError(msg)
 
     @property
     def _type(self) -> str:

langchain/output_parsers/combining.py

@@ -4,6 +4,9 @@ from typing import Any
 
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.utils import pre_init
+from typing_extensions import override
+
+_MIN_PARSERS = 2
 
 
 class CombiningOutputParser(BaseOutputParser[dict[str, Any]]):
@@ -12,6 +15,7 @@ class CombiningOutputParser(BaseOutputParser[dict[str, Any]]):
     parsers: list[BaseOutputParser]
 
     @classmethod
+    @override
     def is_lc_serializable(cls) -> bool:
         return True
 
@@ -19,13 +23,16 @@ class CombiningOutputParser(BaseOutputParser[dict[str, Any]]):
     def validate_parsers(cls, values: dict[str, Any]) -> dict[str, Any]:
         """Validate the parsers."""
         parsers = values["parsers"]
-        if len(parsers) < 2:
-            raise ValueError("Must have at least two parsers")
+        if len(parsers) < _MIN_PARSERS:
+            msg = "Must have at least two parsers"
+            raise ValueError(msg)
         for parser in parsers:
-            if parser._type == "combining":
-                raise ValueError("Cannot nest combining parsers")
-            if parser._type == "list":
-                raise ValueError("Cannot combine list parsers")
+            if parser._type == "combining":  # noqa: SLF001
+                msg = "Cannot nest combining parsers"
+                raise ValueError(msg)
+            if parser._type == "list":  # noqa: SLF001
+                msg = "Cannot combine list parsers"
+                raise ValueError(msg)
         return values
 
     @property
@@ -46,7 +53,7 @@ class CombiningOutputParser(BaseOutputParser[dict[str, Any]]):
     def parse(self, text: str) -> dict[str, Any]:
         """Parse the output of an LLM call."""
         texts = text.split("\n\n")
-        output = dict()
+        output = {}
         for txt, parser in zip(texts, self.parsers):
             output.update(parser.parse(txt.strip()))
         return output

langchain/output_parsers/datetime.py

@@ -1,42 +1,43 @@
-import random
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 from langchain_core.exceptions import OutputParserException
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.utils import comma_list
 
 
-def _generate_random_datetime_strings(
-    pattern: str,
-    n: int = 3,
-    start_date: datetime = datetime(1, 1, 1),
-    end_date: datetime = datetime.now() + timedelta(days=3650),
-) -> list[str]:
-    """Generates n random datetime strings conforming to the
-    given pattern within the specified date range.
-
-    Pattern should be a string containing the desired format codes.
-    start_date and end_date should be datetime objects representing
-    the start and end of the date range.
-    """
-    examples = []
-    delta = end_date - start_date
-    for i in range(n):
-        random_delta = random.uniform(0, delta.total_seconds())
-        dt = start_date + timedelta(seconds=random_delta)
-        date_string = dt.strftime(pattern)
-        examples.append(date_string)
-    return examples
-
-
 class DatetimeOutputParser(BaseOutputParser[datetime]):
     """Parse the output of an LLM call to a datetime."""
 
     format: str = "%Y-%m-%dT%H:%M:%S.%fZ"
-    """The string value that used as the datetime format."""
+    """The string value that is used as the datetime format.
+
+    Update this to match the desired datetime format for your application.
+    """
 
     def get_format_instructions(self) -> str:
-        examples = comma_list(_generate_random_datetime_strings(self.format))
+        """Returns the format instructions for the given format."""
+        if self.format == "%Y-%m-%dT%H:%M:%S.%fZ":
+            examples = comma_list(
+                [
+                    "2023-07-04T14:30:00.000000Z",
+                    "1999-12-31T23:59:59.999999Z",
+                    "2025-01-01T00:00:00.000000Z",
+                ],
+            )
+        else:
+            try:
+                now = datetime.now(tz=timezone.utc)
+                examples = comma_list(
+                    [
+                        now.strftime(self.format),
+                        (now.replace(year=now.year - 1)).strftime(self.format),
+                        (now - timedelta(days=1)).strftime(self.format),
+                    ],
+                )
+            except ValueError:
+                # Fallback if the format is very unusual
+                examples = f"e.g., a valid string in the format {self.format}"
+
         return (
             f"Write a datetime string that matches the "
             f"following pattern: '{self.format}'.\n\n"
@@ -45,12 +46,12 @@ class DatetimeOutputParser(BaseOutputParser[datetime]):
         )
 
     def parse(self, response: str) -> datetime:
+        """Parse a string into a datetime object."""
         try:
-            return datetime.strptime(response.strip(), self.format)
+            return datetime.strptime(response.strip(), self.format)  # noqa: DTZ007
         except ValueError as e:
-            raise OutputParserException(
-                f"Could not parse datetime string: {response}"
-            ) from e
+            msg = f"Could not parse datetime string: {response}"
+            raise OutputParserException(msg) from e
 
     @property
     def _type(self) -> str:

langchain/output_parsers/enum.py

@@ -3,6 +3,7 @@ from enum import Enum
 from langchain_core.exceptions import OutputParserException
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.utils import pre_init
+from typing_extensions import override
 
 
 class EnumOutputParser(BaseOutputParser[Enum]):
@@ -12,28 +13,33 @@ class EnumOutputParser(BaseOutputParser[Enum]):
     """The enum to parse. Its values must be strings."""
 
     @pre_init
-    def raise_deprecation(cls, values: dict) -> dict:
+    def _raise_deprecation(cls, values: dict) -> dict:
         enum = values["enum"]
         if not all(isinstance(e.value, str) for e in enum):
-            raise ValueError("Enum values must be strings")
+            msg = "Enum values must be strings"
+            raise ValueError(msg)
         return values
 
     @property
     def _valid_values(self) -> list[str]:
         return [e.value for e in self.enum]
 
+    @override
     def parse(self, response: str) -> Enum:
         try:
             return self.enum(response.strip())
-        except ValueError:
-            raise OutputParserException(
+        except ValueError as e:
+            msg = (
                 f"Response '{response}' is not one of the "
                 f"expected values: {self._valid_values}"
             )
+            raise OutputParserException(msg) from e
 
+    @override
     def get_format_instructions(self) -> str:
         return f"Select one of the following options: {', '.join(self._valid_values)}"
 
     @property
+    @override
     def OutputType(self) -> type[Enum]:
         return self.enum