langchain-core 0.3.68__py3-none-any.whl → 0.3.70__py3-none-any.whl

langchain_core/messages/utils.py

@@ -138,34 +138,34 @@ def get_buffer_string(
 
 
 def _message_from_dict(message: dict) -> BaseMessage:
-    _type = message["type"]
-    if _type == "human":
+    type_ = message["type"]
+    if type_ == "human":
         return HumanMessage(**message["data"])
-    if _type == "ai":
+    if type_ == "ai":
         return AIMessage(**message["data"])
-    if _type == "system":
+    if type_ == "system":
         return SystemMessage(**message["data"])
-    if _type == "chat":
+    if type_ == "chat":
         return ChatMessage(**message["data"])
-    if _type == "function":
+    if type_ == "function":
         return FunctionMessage(**message["data"])
-    if _type == "tool":
+    if type_ == "tool":
         return ToolMessage(**message["data"])
-    if _type == "remove":
+    if type_ == "remove":
         return RemoveMessage(**message["data"])
-    if _type == "AIMessageChunk":
+    if type_ == "AIMessageChunk":
         return AIMessageChunk(**message["data"])
-    if _type == "HumanMessageChunk":
+    if type_ == "HumanMessageChunk":
         return HumanMessageChunk(**message["data"])
-    if _type == "FunctionMessageChunk":
+    if type_ == "FunctionMessageChunk":
         return FunctionMessageChunk(**message["data"])
-    if _type == "ToolMessageChunk":
+    if type_ == "ToolMessageChunk":
         return ToolMessageChunk(**message["data"])
-    if _type == "SystemMessageChunk":
+    if type_ == "SystemMessageChunk":
         return SystemMessageChunk(**message["data"])
-    if _type == "ChatMessageChunk":
+    if type_ == "ChatMessageChunk":
         return ChatMessageChunk(**message["data"])
-    msg = f"Got unexpected message type: {_type}"
+    msg = f"Got unexpected message type: {type_}"
     raise ValueError(msg)
 
 
@@ -263,15 +263,15 @@ def _create_message_from_message_type(
                 )
             else:
                 kwargs["tool_calls"].append(tool_call)
-    if message_type in ("human", "user"):
+    if message_type in {"human", "user"}:
         if example := kwargs.get("additional_kwargs", {}).pop("example", False):
             kwargs["example"] = example
         message: BaseMessage = HumanMessage(content=content, **kwargs)
-    elif message_type in ("ai", "assistant"):
+    elif message_type in {"ai", "assistant"}:
         if example := kwargs.get("additional_kwargs", {}).pop("example", False):
             kwargs["example"] = example
         message = AIMessage(content=content, **kwargs)
-    elif message_type in ("system", "developer"):
+    elif message_type in {"system", "developer"}:
         if message_type == "developer":
             kwargs["additional_kwargs"] = kwargs.get("additional_kwargs") or {}
             kwargs["additional_kwargs"]["__openai_role__"] = "developer"
@@ -315,13 +315,13 @@ def _convert_to_message(message: MessageLikeRepresentation) -> BaseMessage:
         ValueError: if the message dict does not contain the required keys.
     """
     if isinstance(message, BaseMessage):
-        _message = message
+        message_ = message
     elif isinstance(message, str):
-        _message = _create_message_from_message_type("human", message)
+        message_ = _create_message_from_message_type("human", message)
     elif isinstance(message, Sequence) and len(message) == 2:
         # mypy doesn't realise this can't be a string given the previous branch
         message_type_str, template = message  # type: ignore[misc]
-        _message = _create_message_from_message_type(message_type_str, template)
+        message_ = _create_message_from_message_type(message_type_str, template)
     elif isinstance(message, dict):
         msg_kwargs = message.copy()
         try:
@@ -337,7 +337,7 @@ def _convert_to_message(message: MessageLikeRepresentation) -> BaseMessage:
                 message=msg, error_code=ErrorCode.MESSAGE_COERCION_FAILURE
             )
             raise ValueError(msg) from e
-        _message = _create_message_from_message_type(
+        message_ = _create_message_from_message_type(
             msg_type, msg_content, **msg_kwargs
         )
     else:
@@ -345,7 +345,7 @@ def _convert_to_message(message: MessageLikeRepresentation) -> BaseMessage:
         msg = create_message(message=msg, error_code=ErrorCode.MESSAGE_COERCION_FAILURE)
         raise NotImplementedError(msg)
 
-    return _message
+    return message_
 
 
 def convert_to_messages(
@@ -370,7 +370,7 @@ def convert_to_messages(
 def _runnable_support(func: Callable) -> Callable:
     @overload
     def wrapped(
-        messages: Literal[None] = None, **kwargs: Any
+        messages: None = None, **kwargs: Any
     ) -> Runnable[Sequence[MessageLikeRepresentation], list[BaseMessage]]: ...
 
     @overload
@@ -519,8 +519,6 @@ def filter_messages(
             or (include_ids and msg.id in include_ids)
         ):
             filtered.append(msg)
-        else:
-            pass
 
     return filtered
 
@@ -1000,7 +998,7 @@ def convert_to_openai_messages(
     .. versionadded:: 0.3.11
 
     """  # noqa: E501
-    if text_format not in ("string", "block"):
+    if text_format not in {"string", "block"}:
         err = f"Unrecognized {text_format=}, expected one of 'string' or 'block'."
         raise ValueError(err)
 
@@ -1125,8 +1123,7 @@ def convert_to_openai_messages(
                                 "type": "image_url",
                                 "image_url": {
                                     "url": (
-                                        f"data:image/{image['format']};"
-                                        f"base64,{b64_image}"
+                                        f"data:image/{image['format']};base64,{b64_image}"
                                     )
                                 },
                             }
@@ -1341,8 +1338,8 @@ def _first_max_tokens(
                 excluded.content = list(reversed(excluded.content))
             for _ in range(1, num_block):
                 excluded.content = excluded.content[:-1]
-                if token_counter(messages[:idx] + [excluded]) <= max_tokens:
-                    messages = messages[:idx] + [excluded]
+                if token_counter([*messages[:idx], excluded]) <= max_tokens:
+                    messages = [*messages[:idx], excluded]
                     idx += 1
                     included_partial = True
                     break
@@ -1393,7 +1390,7 @@ def _first_max_tokens(
                     if partial_strategy == "last":
                         content_splits = list(reversed(content_splits))
                     excluded.content = "".join(content_splits)
-                    messages = messages[:idx] + [excluded]
+                    messages = [*messages[:idx], excluded]
                     idx += 1
 
     if end_on:

langchain_core/output_parsers/base.py

@@ -28,7 +28,7 @@ T = TypeVar("T")
 OutputParserLike = Runnable[LanguageModelOutput, T]
 
 
-class BaseLLMOutputParser(Generic[T], ABC):
+class BaseLLMOutputParser(ABC, Generic[T]):
     """Abstract base class for parsing the outputs of a model."""
 
     @abstractmethod

langchain_core/output_parsers/openai_functions.py

@@ -263,23 +263,23 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
         Returns:
             The parsed JSON object.
         """
-        _result = super().parse_result(result)
+        result_ = super().parse_result(result)
         if self.args_only:
             if hasattr(self.pydantic_schema, "model_validate_json"):
-                pydantic_args = self.pydantic_schema.model_validate_json(_result)
+                pydantic_args = self.pydantic_schema.model_validate_json(result_)
             else:
-                pydantic_args = self.pydantic_schema.parse_raw(_result)  # type: ignore[attr-defined]
+                pydantic_args = self.pydantic_schema.parse_raw(result_)  # type: ignore[attr-defined]
         else:
-            fn_name = _result["name"]
-            _args = _result["arguments"]
+            fn_name = result_["name"]
+            args = result_["arguments"]
             if isinstance(self.pydantic_schema, dict):
                 pydantic_schema = self.pydantic_schema[fn_name]
             else:
                 pydantic_schema = self.pydantic_schema
             if issubclass(pydantic_schema, BaseModel):
-                pydantic_args = pydantic_schema.model_validate_json(_args)
+                pydantic_args = pydantic_schema.model_validate_json(args)
             elif issubclass(pydantic_schema, BaseModelV1):
-                pydantic_args = pydantic_schema.parse_raw(_args)
+                pydantic_args = pydantic_schema.parse_raw(args)
             else:
                 msg = f"Unsupported pydantic schema: {pydantic_schema}"
                 raise ValueError(msg)

langchain_core/output_parsers/openai_tools.py

@@ -234,12 +234,39 @@ class JsonOutputKeyToolsParser(JsonOutputToolsParser):
         Returns:
             The parsed tool calls.
         """
-        parsed_result = super().parse_result(result, partial=partial)
-
+        generation = result[0]
+        if not isinstance(generation, ChatGeneration):
+            msg = "This output parser can only be used with a chat generation."
+            raise OutputParserException(msg)
+        message = generation.message
+        if isinstance(message, AIMessage) and message.tool_calls:
+            parsed_tool_calls = [dict(tc) for tc in message.tool_calls]
+            for tool_call in parsed_tool_calls:
+                if not self.return_id:
+                    _ = tool_call.pop("id")
+        else:
+            try:
+                raw_tool_calls = copy.deepcopy(message.additional_kwargs["tool_calls"])
+            except KeyError:
+                if self.first_tool_only:
+                    return None
+                return []
+            parsed_tool_calls = parse_tool_calls(
+                raw_tool_calls,
+                partial=partial,
+                strict=self.strict,
+                return_id=self.return_id,
+            )
+        # For backwards compatibility
+        for tc in parsed_tool_calls:
+            tc["type"] = tc.pop("name")
         if self.first_tool_only:
+            parsed_result = list(
+                filter(lambda x: x["type"] == self.key_name, parsed_tool_calls)
+            )
             single_result = (
-                parsed_result
-                if parsed_result and parsed_result["type"] == self.key_name
+                parsed_result[0]
+                if parsed_result and parsed_result[0]["type"] == self.key_name
                 else None
             )
             if self.return_id:
@@ -247,10 +274,13 @@ class JsonOutputKeyToolsParser(JsonOutputToolsParser):
             if single_result:
                 return single_result["args"]
             return None
-        parsed_result = [res for res in parsed_result if res["type"] == self.key_name]
-        if not self.return_id:
-            parsed_result = [res["args"] for res in parsed_result]
-        return parsed_result
+        return (
+            [res for res in parsed_tool_calls if res["type"] == self.key_name]
+            if self.return_id
+            else [
+                res["args"] for res in parsed_tool_calls if res["type"] == self.key_name
+            ]
+        )
 
 
 # Common cause of ValidationError is truncated output due to max_tokens.

langchain_core/output_parsers/xml.py

@@ -61,10 +61,10 @@ class _StreamingParser:
                     "You can install it with `pip install defusedxml` "
                 )
                 raise ImportError(msg) from e
-            _parser = XMLParser(target=TreeBuilder())
+            parser_ = XMLParser(target=TreeBuilder())
         else:
-            _parser = None
-        self.pull_parser = ET.XMLPullParser(["start", "end"], _parser=_parser)
+            parser_ = None
+        self.pull_parser = ET.XMLPullParser(["start", "end"], _parser=parser_)
         self.xml_start_re = re.compile(r"<[a-zA-Z:_]")
         self.current_path: list[str] = []
         self.current_path_has_children = False
@@ -218,9 +218,9 @@ class XMLOutputParser(BaseTransformOutputParser):
                     "See https://github.com/tiran/defusedxml for more details"
                 )
                 raise ImportError(msg) from e
-            _et = ElementTree  # Use the defusedxml parser
+            et = ElementTree  # Use the defusedxml parser
         else:
-            _et = ET  # Use the standard library parser
+            et = ET  # Use the standard library parser
 
         match = re.search(r"```(xml)?(.*)```", text, re.DOTALL)
         if match is not None:
@@ -232,9 +232,9 @@ class XMLOutputParser(BaseTransformOutputParser):
 
         text = text.strip()
         try:
-            root = _et.fromstring(text)
+            root = et.fromstring(text)
             return self._root_to_dict(root)
-        except _et.ParseError as e:
+        except et.ParseError as e:
             msg = f"Failed to parse XML format from completion {text}. Got: {e}"
             raise OutputParserException(msg, llm_output=text) from e
 

langchain_core/outputs/__init__.py

@@ -1,24 +1,23 @@
 """Output classes.
 
-**Output** classes are used to represent the output of a language model call
-and the output of a chat.
+Used to represent the output of a language model call and the output of a chat.
 
-The top container for information is the `LLMResult` object. `LLMResult` is used by
-both chat models and LLMs. This object contains the output of the language
-model and any additional information that the model provider wants to return.
+The top container for information is the `LLMResult` object. `LLMResult` is used by both
+chat models and LLMs. This object contains the output of the language model and any
+additional information that the model provider wants to return.
 
 When invoking models via the standard runnable methods (e.g. invoke, batch, etc.):
+
 - Chat models will return `AIMessage` objects.
 - LLMs will return regular text strings.
 
 In addition, users can access the raw output of either LLMs or chat models via
-callbacks. The on_chat_model_end and on_llm_end callbacks will return an
+callbacks. The ``on_chat_model_end`` and ``on_llm_end`` callbacks will return an
 LLMResult object containing the generated outputs and any additional information
 returned by the model provider.
 
-In general, if information is already available
-in the AIMessage object, it is recommended to access it from there rather than
-from the `LLMResult` object.
+In general, if information is already available in the AIMessage object, it is
+recommended to access it from there rather than from the `LLMResult` object.
 """
 
 from typing import TYPE_CHECKING

langchain_core/outputs/chat_generation.py

@@ -27,7 +27,11 @@ class ChatGeneration(Generation):
     """
 
     text: str = ""
-    """*SHOULD NOT BE SET DIRECTLY* The text contents of the output message."""
+    """The text contents of the output message.
+
+    .. warning::
+        SHOULD NOT BE SET DIRECTLY!
+    """
     message: BaseMessage
     """The message output by the chat model."""
     # Override type to be ChatGeneration, ignore mypy error as this is intentional
@@ -60,8 +64,6 @@ class ChatGeneration(Generation):
                 if isinstance(block, dict) and "text" in block:
                     text = block["text"]
                     break
-        else:
-            pass
         self.text = text
         return self
 

langchain_core/outputs/generation.py

@@ -11,7 +11,8 @@ from langchain_core.utils._merge import merge_dicts
 class Generation(Serializable):
     """A single text generation output.
 
-    Generation represents the response from an "old-fashioned" LLM that
+    Generation represents the response from an
+    `"old-fashioned" LLM <https://python.langchain.com/docs/concepts/text_llms/>__` that
     generates regular text (not chat messages).
 
     This model is used internally by chat model and will eventually

langchain_core/outputs/llm_result.py

@@ -15,9 +15,9 @@ from langchain_core.outputs.run_info import RunInfo
 class LLMResult(BaseModel):
     """A container for results of an LLM call.
 
-    Both chat models and LLMs generate an LLMResult object. This object contains
-    the generated outputs and any additional information that the model provider
-    wants to return.
+    Both chat models and LLMs generate an LLMResult object. This object contains the
+    generated outputs and any additional information that the model provider wants to
+    return.
     """
 
     generations: list[
@@ -25,17 +25,16 @@ class LLMResult(BaseModel):
     ]
     """Generated outputs.
 
-    The first dimension of the list represents completions for different input
-    prompts.
+    The first dimension of the list represents completions for different input prompts.
 
-    The second dimension of the list represents different candidate generations
-    for a given prompt.
+    The second dimension of the list represents different candidate generations for a
+    given prompt.
 
-    When returned from an LLM the type is list[list[Generation]].
-    When returned from a chat model the type is list[list[ChatGeneration]].
+    - When returned from **an LLM**, the type is ``list[list[Generation]]``.
+    - When returned from a **chat model**, the type is ``list[list[ChatGeneration]]``.
 
-    ChatGeneration is a subclass of Generation that has a field for a structured
-    chat message.
+    ChatGeneration is a subclass of Generation that has a field for a structured chat
+    message.
     """
     llm_output: Optional[dict] = None
     """For arbitrary LLM provider specific output.
@@ -43,9 +42,8 @@ class LLMResult(BaseModel):
     This dictionary is a free-form dictionary that can contain any information that the
     provider wants to return. It is not standardized and is provider-specific.
 
-    Users should generally avoid relying on this field and instead rely on
-    accessing relevant information from standardized fields present in
-    AIMessage.
+    Users should generally avoid relying on this field and instead rely on accessing
+    relevant information from standardized fields present in AIMessage.
     """
     run: Optional[list[RunInfo]] = None
     """List of metadata info for model call for each input."""
@@ -97,3 +95,5 @@ class LLMResult(BaseModel):
             self.generations == other.generations
             and self.llm_output == other.llm_output
         )
+
+    __hash__ = None  # type: ignore[assignment]

langchain_core/prompts/base.py

@@ -43,7 +43,7 @@ FormatOutputType = TypeVar("FormatOutputType")
 
 
 class BasePromptTemplate(
-    RunnableSerializable[dict, PromptValue], Generic[FormatOutputType], ABC
+    RunnableSerializable[dict, PromptValue], ABC, Generic[FormatOutputType]
 ):
     """Base class for all prompt templates, returning a prompt."""
 
@@ -186,14 +186,14 @@ class BasePromptTemplate(
         return inner_input
 
     def _format_prompt_with_error_handling(self, inner_input: dict) -> PromptValue:
-        _inner_input = self._validate_input(inner_input)
-        return self.format_prompt(**_inner_input)
+        inner_input_ = self._validate_input(inner_input)
+        return self.format_prompt(**inner_input_)
 
     async def _aformat_prompt_with_error_handling(
         self, inner_input: dict
     ) -> PromptValue:
-        _inner_input = self._validate_input(inner_input)
-        return await self.aformat_prompt(**_inner_input)
+        inner_input_ = self._validate_input(inner_input)
+        return await self.aformat_prompt(**inner_input_)
 
     @override
     def invoke(

langchain_core/prompts/chat.py

@@ -35,7 +35,7 @@ from langchain_core.messages import (
     convert_to_messages,
 )
 from langchain_core.messages.base import get_msg_title_repr
-from langchain_core.prompt_values import ChatPromptValue, ImageURL, PromptValue
+from langchain_core.prompt_values import ChatPromptValue, ImageURL
 from langchain_core.prompts.base import BasePromptTemplate
 from langchain_core.prompts.dict import DictPromptTemplate
 from langchain_core.prompts.image import ImagePromptTemplate
@@ -545,6 +545,7 @@ class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
             A new instance of this class.
         """
         template = Path(template_file).read_text()
+        # TODO: .read_text(encoding="utf-8") for v0.4
         return cls.from_template(template, input_variables=input_variables, **kwargs)
 
     def format_messages(self, **kwargs: Any) -> list[BaseMessage]:
@@ -714,20 +715,20 @@ class BaseChatPromptTemplate(BasePromptTemplate, ABC):
         """
         return (await self.aformat_prompt(**kwargs)).to_string()
 
-    def format_prompt(self, **kwargs: Any) -> PromptValue:
-        """Format prompt. Should return a PromptValue.
+    def format_prompt(self, **kwargs: Any) -> ChatPromptValue:
+        """Format prompt. Should return a ChatPromptValue.
 
         Args:
             **kwargs: Keyword arguments to use for formatting.
 
         Returns:
-            PromptValue.
+            ChatPromptValue.
         """
         messages = self.format_messages(**kwargs)
         return ChatPromptValue(messages=messages)
 
-    async def aformat_prompt(self, **kwargs: Any) -> PromptValue:
-        """Async format prompt. Should return a PromptValue.
+    async def aformat_prompt(self, **kwargs: Any) -> ChatPromptValue:
+        """Async format prompt. Should return a ChatPromptValue.
 
         Args:
             **kwargs: Keyword arguments to use for formatting.
@@ -946,7 +947,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
                 ])
 
         """
-        _messages = [
+        messages_ = [
             _convert_to_message_template(message, template_format)
             for message in messages
         ]
@@ -955,7 +956,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
         input_vars: set[str] = set()
         optional_variables: set[str] = set()
         partial_vars: dict[str, Any] = {}
-        for _message in _messages:
+        for _message in messages_:
             if isinstance(_message, MessagesPlaceholder) and _message.optional:
                 partial_vars[_message.variable_name] = []
                 optional_variables.add(_message.variable_name)
@@ -970,7 +971,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
             "partial_variables": partial_vars,
             **kwargs,
         }
-        cast("type[ChatPromptTemplate]", super()).__init__(messages=_messages, **kwargs)
+        cast("type[ChatPromptTemplate]", super()).__init__(messages=messages_, **kwargs)
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
@@ -1005,8 +1006,8 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
                 **partials
             )
         if isinstance(other, (list, tuple)):
-            _other = ChatPromptTemplate.from_messages(other)
-            return ChatPromptTemplate(messages=self.messages + _other.messages).partial(
+            other_ = ChatPromptTemplate.from_messages(other)
+            return ChatPromptTemplate(messages=self.messages + other_.messages).partial(
                 **partials
             )
         if isinstance(other, str):
@@ -1053,9 +1054,9 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
                 if message.variable_name not in input_types:
                     input_types[message.variable_name] = list[AnyMessage]
         if "partial_variables" in values:
-            input_vars = input_vars - set(values["partial_variables"])
+            input_vars -= set(values["partial_variables"])
         if optional_variables:
-            input_vars = input_vars - optional_variables
+            input_vars -= optional_variables
         if "input_variables" in values and values.get("validate_template"):
             if input_vars != set(values["input_variables"]):
                 msg = (
@@ -1338,11 +1339,11 @@ def _create_template_from_message_type(
     Raises:
         ValueError: If unexpected message type.
     """
-    if message_type in ("human", "user"):
+    if message_type in {"human", "user"}:
         message: BaseMessagePromptTemplate = HumanMessagePromptTemplate.from_template(
             template, template_format=template_format
         )
-    elif message_type in ("ai", "assistant"):
+    elif message_type in {"ai", "assistant"}:
         message = AIMessagePromptTemplate.from_template(
             cast("str", template), template_format=template_format
         )
@@ -1417,13 +1418,13 @@ def _convert_to_message_template(
         ValueError: If 2-tuple does not have 2 elements.
     """
     if isinstance(message, (BaseMessagePromptTemplate, BaseChatPromptTemplate)):
-        _message: Union[
+        message_: Union[
             BaseMessage, BaseMessagePromptTemplate, BaseChatPromptTemplate
         ] = message
     elif isinstance(message, BaseMessage):
-        _message = message
+        message_ = message
     elif isinstance(message, str):
-        _message = _create_template_from_message_type(
+        message_ = _create_template_from_message_type(
             "human", message, template_format=template_format
         )
     elif isinstance(message, (tuple, dict)):
@@ -1440,11 +1441,11 @@ def _convert_to_message_template(
             raise ValueError(msg)
         message_type_str, template = message
         if isinstance(message_type_str, str):
-            _message = _create_template_from_message_type(
+            message_ = _create_template_from_message_type(
                 message_type_str, template, template_format=template_format
             )
         else:
-            _message = message_type_str(
+            message_ = message_type_str(
                 prompt=PromptTemplate.from_template(
                     cast("str", template), template_format=template_format
                 )
@@ -1453,7 +1454,7 @@ def _convert_to_message_template(
         msg = f"Unsupported message type: {type(message)}"
         raise NotImplementedError(msg)
 
-    return _message
+    return message_
 
 
 # For backwards compat:

langchain_core/prompts/dict.py

@@ -100,8 +100,6 @@ def _get_input_variables(
                     input_variables += get_template_variables(x, template_format)
                 elif isinstance(x, dict):
                     input_variables += _get_input_variables(x, template_format)
-        else:
-            pass
     return list(set(input_variables))