langchain 0.3.26__py3-none-any.whl → 0.3.27__py3-none-any.whl

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

@@ -5,6 +5,8 @@ from typing import Any
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.utils import pre_init
 
+_MIN_PARSERS = 2
+
 
 class CombiningOutputParser(BaseOutputParser[dict[str, Any]]):
     """Combine multiple output parsers into one."""
@@ -19,13 +21,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")
+                msg = "Cannot nest combining parsers"
+                raise ValueError(msg)
             if parser._type == "list":
-                raise ValueError("Cannot combine list parsers")
+                msg = "Cannot combine list parsers"
+                raise ValueError(msg)
         return values
 
     @property
@@ -46,7 +51,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

@@ -15,7 +15,8 @@ class EnumOutputParser(BaseOutputParser[Enum]):
     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
@@ -25,11 +26,12 @@ class EnumOutputParser(BaseOutputParser[Enum]):
     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
 
     def get_format_instructions(self) -> str:
         return f"Select one of the following options: {', '.join(self._valid_values)}"

langchain/output_parsers/fix.py

@@ -70,34 +70,34 @@ class OutputFixingParser(BaseOutputParser[T]):
                 return self.parser.parse(completion)
             except OutputParserException as e:
                 if retries == self.max_retries:
-                    raise e
+                    raise
+                retries += 1
+                if self.legacy and hasattr(self.retry_chain, "run"):
+                    completion = self.retry_chain.run(
+                        instructions=self.parser.get_format_instructions(),
+                        completion=completion,
+                        error=repr(e),
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "run"):
-                        completion = self.retry_chain.run(
-                            instructions=self.parser.get_format_instructions(),
-                            completion=completion,
-                            error=repr(e),
+                    try:
+                        completion = self.retry_chain.invoke(
+                            {
+                                "instructions": self.parser.get_format_instructions(),
+                                "completion": completion,
+                                "error": repr(e),
+                            },
                         )
-                    else:
-                        try:
-                            completion = self.retry_chain.invoke(
-                                dict(
-                                    instructions=self.parser.get_format_instructions(),
-                                    completion=completion,
-                                    error=repr(e),
-                                )
-                            )
-                        except (NotImplementedError, AttributeError):
-                            # Case: self.parser does not have get_format_instructions
-                            completion = self.retry_chain.invoke(
-                                dict(
-                                    completion=completion,
-                                    error=repr(e),
-                                )
-                            )
-
-        raise OutputParserException("Failed to parse")
+                    except (NotImplementedError, AttributeError):
+                        # Case: self.parser does not have get_format_instructions
+                        completion = self.retry_chain.invoke(
+                            {
+                                "completion": completion,
+                                "error": repr(e),
+                            },
+                        )
+
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
 
     async def aparse(self, completion: str) -> T:
         retries = 0
@@ -107,34 +107,34 @@ class OutputFixingParser(BaseOutputParser[T]):
                 return await self.parser.aparse(completion)
             except OutputParserException as e:
                 if retries == self.max_retries:
-                    raise e
+                    raise
+                retries += 1
+                if self.legacy and hasattr(self.retry_chain, "arun"):
+                    completion = await self.retry_chain.arun(
+                        instructions=self.parser.get_format_instructions(),
+                        completion=completion,
+                        error=repr(e),
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "arun"):
-                        completion = await self.retry_chain.arun(
-                            instructions=self.parser.get_format_instructions(),
-                            completion=completion,
-                            error=repr(e),
+                    try:
+                        completion = await self.retry_chain.ainvoke(
+                            {
+                                "instructions": self.parser.get_format_instructions(),
+                                "completion": completion,
+                                "error": repr(e),
+                            },
                         )
-                    else:
-                        try:
-                            completion = await self.retry_chain.ainvoke(
-                                dict(
-                                    instructions=self.parser.get_format_instructions(),
-                                    completion=completion,
-                                    error=repr(e),
-                                )
-                            )
-                        except (NotImplementedError, AttributeError):
-                            # Case: self.parser does not have get_format_instructions
-                            completion = await self.retry_chain.ainvoke(
-                                dict(
-                                    completion=completion,
-                                    error=repr(e),
-                                )
-                            )
-
-        raise OutputParserException("Failed to parse")
+                    except (NotImplementedError, AttributeError):
+                        # Case: self.parser does not have get_format_instructions
+                        completion = await self.retry_chain.ainvoke(
+                            {
+                                "completion": completion,
+                                "error": repr(e),
+                            },
+                        )
+
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
 
     def get_format_instructions(self) -> str:
         return self.parser.get_format_instructions()

langchain/output_parsers/format_instructions.py

@@ -1,12 +1,10 @@
-# flake8: noqa
-
 STRUCTURED_FORMAT_INSTRUCTIONS = """The output should be a markdown code snippet formatted in the following schema, including the leading and trailing "```json" and "```":
 
 ```json
 {{
 {format}
 }}
-```"""
+```"""  # noqa: E501
 
 STRUCTURED_FORMAT_SIMPLE_INSTRUCTIONS = """
 ```json
@@ -24,7 +22,7 @@ the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of the schema.
 Here is the output schema:
 ```
 {schema}
-```"""
+```"""  # noqa: E501
 
 YAML_FORMAT_INSTRUCTIONS = """The output should be formatted as a YAML instance that conforms to the given JSON schema below.
 
@@ -49,14 +47,14 @@ YAML_FORMAT_INSTRUCTIONS = """The output should be formatted as a YAML instance
 ```
 habit: Using disposable water bottles for daily hydration.
 sustainable_alternative: Switch to a reusable water bottle to reduce plastic waste and decrease your environmental footprint.
-``` 
+```
 
-Please follow the standard YAML formatting conventions with an indent of 2 spaces and make sure that the data types adhere strictly to the following JSON schema: 
+Please follow the standard YAML formatting conventions with an indent of 2 spaces and make sure that the data types adhere strictly to the following JSON schema:
 ```
 {schema}
 ```
 
-Make sure to always enclose the YAML output in triple backticks (```). Please do not add anything other than valid YAML output!"""
+Make sure to always enclose the YAML output in triple backticks (```). Please do not add anything other than valid YAML output!"""  # noqa: E501
 
 
 PANDAS_DATAFRAME_FORMAT_INSTRUCTIONS = """The output should be formatted as a string as the operation, followed by a colon, followed by the column or row to be queried on, followed by optional array parameters.
@@ -78,4 +76,4 @@ Here are the possible columns:
 ```
 {columns}
 ```
-"""
+"""  # noqa: E501

langchain/output_parsers/json.py

@@ -9,7 +9,7 @@ from langchain_core.utils.json import (
 
 __all__ = [
     "SimpleJsonOutputParser",
-    "parse_partial_json",
-    "parse_json_markdown",
     "parse_and_check_json_markdown",
+    "parse_json_markdown",
+    "parse_partial_json",
 ]

langchain/output_parsers/list.py

@@ -6,8 +6,8 @@ from langchain_core.output_parsers.list import (
 )
 
 __all__ = [
-    "ListOutputParser",
     "CommaSeparatedListOutputParser",
-    "NumberedListOutputParser",
+    "ListOutputParser",
     "MarkdownListOutputParser",
+    "NumberedListOutputParser",
 ]

langchain/output_parsers/loading.py

@@ -10,13 +10,13 @@ def load_output_parser(config: dict) -> dict:
     Returns:
         config dict with output parser loaded
     """
-    if "output_parsers" in config:
-        if config["output_parsers"] is not None:
-            _config = config["output_parsers"]
-            output_parser_type = _config["_type"]
-            if output_parser_type == "regex_parser":
-                output_parser = RegexParser(**_config)
-            else:
-                raise ValueError(f"Unsupported output parser {output_parser_type}")
-            config["output_parsers"] = output_parser
+    if "output_parsers" in config and config["output_parsers"] is not None:
+        _config = config["output_parsers"]
+        output_parser_type = _config["_type"]
+        if output_parser_type == "regex_parser":
+            output_parser = RegexParser(**_config)
+        else:
+            msg = f"Unsupported output parser {output_parser_type}"
+            raise ValueError(msg)
+        config["output_parsers"] = output_parser
     return config

langchain/output_parsers/openai_functions.py

@@ -6,8 +6,8 @@ from langchain_core.output_parsers.openai_functions import (
 )
 
 __all__ = [
-    "PydanticOutputFunctionsParser",
-    "PydanticAttrOutputFunctionsParser",
-    "JsonOutputFunctionsParser",
     "JsonKeyOutputFunctionsParser",
+    "JsonOutputFunctionsParser",
+    "PydanticAttrOutputFunctionsParser",
+    "PydanticOutputFunctionsParser",
 ]

langchain/output_parsers/openai_tools.py

@@ -4,4 +4,4 @@ from langchain_core.output_parsers.openai_tools import (
     PydanticToolsParser,
 )
 
-__all__ = ["PydanticToolsParser", "JsonOutputToolsParser", "JsonOutputKeyToolsParser"]
+__all__ = ["JsonOutputKeyToolsParser", "JsonOutputToolsParser", "PydanticToolsParser"]