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

langchain/output_parsers/fix.py

@@ -7,7 +7,7 @@ from langchain_core.output_parsers import BaseOutputParser, StrOutputParser
 from langchain_core.prompts import BasePromptTemplate
 from langchain_core.runnables import Runnable, RunnableSerializable
 from pydantic import SkipValidation
-from typing_extensions import TypedDict
+from typing_extensions import TypedDict, override
 
 from langchain.output_parsers.prompts import NAIVE_FIX_PROMPT
 
@@ -15,6 +15,8 @@ T = TypeVar("T")
 
 
 class OutputFixingParserRetryChainInput(TypedDict, total=False):
+    """Input for the retry chain of the OutputFixingParser."""
+
     instructions: str
     completion: str
     error: str
@@ -24,6 +26,7 @@ class OutputFixingParser(BaseOutputParser[T]):
     """Wrap a parser and try to fix parsing errors."""
 
     @classmethod
+    @override
     def is_lc_serializable(cls) -> bool:
         return True
 
@@ -62,6 +65,7 @@ class OutputFixingParser(BaseOutputParser[T]):
         chain = prompt | llm | StrOutputParser()
         return cls(parser=parser, retry_chain=chain, max_retries=max_retries)
 
+    @override
     def parse(self, completion: str) -> T:
         retries = 0
 
@@ -70,35 +74,36 @@ 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),
+                            },
+                        )
+                    except (NotImplementedError, AttributeError):
+                        # Case: self.parser does not have get_format_instructions
+                        completion = self.retry_chain.invoke(
+                            {
+                                "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")
 
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
+
+    @override
     async def aparse(self, completion: str) -> T:
         retries = 0
 
@@ -107,35 +112,36 @@ 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)
 
+    @override
     def get_format_instructions(self) -> str:
         return self.parser.get_format_instructions()
 
@@ -144,5 +150,6 @@ class OutputFixingParser(BaseOutputParser[T]):
         return "output_fixing"
 
     @property
+    @override
     def OutputType(self) -> type[T]:
         return self.parser.OutputType

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"]

langchain/output_parsers/pandas_dataframe.py

@@ -4,6 +4,7 @@ from typing import Any, Union
 from langchain_core.exceptions import OutputParserException
 from langchain_core.output_parsers.base import BaseOutputParser
 from pydantic import field_validator
+from typing_extensions import override
 
 from langchain.output_parsers.format_instructions import (
     PANDAS_DATAFRAME_FORMAT_INSTRUCTIONS,
@@ -18,22 +19,36 @@ class PandasDataFrameOutputParser(BaseOutputParser[dict[str, Any]]):
 
     @field_validator("dataframe")
     @classmethod
-    def validate_dataframe(cls, val: Any) -> Any:
+    def _validate_dataframe(cls, val: Any) -> Any:
         import pandas as pd
 
         if issubclass(type(val), pd.DataFrame):
             return val
         if pd.DataFrame(val).empty:
-            raise ValueError("DataFrame cannot be empty.")
+            msg = "DataFrame cannot be empty."
+            raise ValueError(msg)
 
-        raise TypeError(
-            "Wrong type for 'dataframe', must be a subclass \
+        msg = "Wrong type for 'dataframe', must be a subclass \
                 of Pandas DataFrame (pd.DataFrame)"
-        )
+        raise TypeError(msg)
 
     def parse_array(
-        self, array: str, original_request_params: str
+        self,
+        array: str,
+        original_request_params: str,
     ) -> tuple[list[Union[int, str]], str]:
+        """Parse the array from the request parameters.
+
+        Args:
+            array: The array string to parse.
+            original_request_params: The original request parameters string.
+
+        Returns:
+            A tuple containing the parsed array and the stripped request parameters.
+
+        Raises:
+            OutputParserException: If the array format is invalid or cannot be parsed.
+        """
         parsed_array: list[Union[int, str]] = []
 
         # Check if the format is [1,3,5]
@@ -46,57 +61,53 @@ class PandasDataFrameOutputParser(BaseOutputParser[dict[str, Any]]):
                 start, end = map(int, match.groups())
                 parsed_array = list(range(start, end + 1))
             else:
-                raise OutputParserException(
-                    f"Unable to parse the array provided in {array}. \
+                msg = f"Unable to parse the array provided in {array}. \
                         Please check the format instructions."
-                )
+                raise OutputParserException(msg)
         # Check if the format is ["column_name"]
         elif re.match(r"\[[a-zA-Z0-9_]+(?:,[a-zA-Z0-9_]+)*\]", array):
             match = re.match(r"\[[a-zA-Z0-9_]+(?:,[a-zA-Z0-9_]+)*\]", array)
             if match:
                 parsed_array = list(map(str, match.group().strip("[]").split(",")))
             else:
-                raise OutputParserException(
-                    f"Unable to parse the array provided in {array}. \
+                msg = f"Unable to parse the array provided in {array}. \
                         Please check the format instructions."
-                )
+                raise OutputParserException(msg)
 
         # Validate the array
         if not parsed_array:
-            raise OutputParserException(
-                f"Invalid array format in '{original_request_params}'. \
+            msg = f"Invalid array format in '{original_request_params}'. \
                     Please check the format instructions."
-            )
-        elif (
+            raise OutputParserException(msg)
+        if (
             isinstance(parsed_array[0], int)
             and parsed_array[-1] > self.dataframe.index.max()
         ):
-            raise OutputParserException(
-                f"The maximum index {parsed_array[-1]} exceeds the maximum index of \
+            msg = f"The maximum index {parsed_array[-1]} exceeds the maximum index of \
                     the Pandas DataFrame {self.dataframe.index.max()}."
-            )
+            raise OutputParserException(msg)
 
         return parsed_array, original_request_params.split("[")[0]
 
+    @override
     def parse(self, request: str) -> dict[str, Any]:
         stripped_request_params = None
         splitted_request = request.strip().split(":")
-        if len(splitted_request) != 2:
-            raise OutputParserException(
-                f"Request '{request}' is not correctly formatted. \
+        if len(splitted_request) != 2:  # noqa: PLR2004
+            msg = f"Request '{request}' is not correctly formatted. \
                     Please refer to the format instructions."
-            )
+            raise OutputParserException(msg)
         result = {}
         try:
             request_type, request_params = splitted_request
             if request_type in {"Invalid column", "Invalid operation"}:
-                raise OutputParserException(
-                    f"{request}. Please check the format instructions."
-                )
+                msg = f"{request}. Please check the format instructions."
+                raise OutputParserException(msg)
             array_exists = re.search(r"(\[.*?\])", request_params)
             if array_exists:
                 parsed_array, stripped_request_params = self.parse_array(
-                    array_exists.group(1), request_params
+                    array_exists.group(1),
+                    request_params,
                 )
                 if request_type == "column":
                     filtered_df = self.dataframe[
@@ -127,34 +138,34 @@ class PandasDataFrameOutputParser(BaseOutputParser[dict[str, Any]]):
                         self.dataframe.index.isin(parsed_array)
                     ]
                     result[request_type] = getattr(
-                        filtered_df[stripped_request_params], request_type
+                        filtered_df[stripped_request_params],
+                        request_type,
                     )()
+            elif request_type == "column":
+                result[request_params] = self.dataframe[request_params]
+            elif request_type == "row":
+                result[request_params] = self.dataframe.iloc[int(request_params)]
             else:
-                if request_type == "column":
-                    result[request_params] = self.dataframe[request_params]
-                elif request_type == "row":
-                    result[request_params] = self.dataframe.iloc[int(request_params)]
-                else:
-                    result[request_type] = getattr(
-                        self.dataframe[request_params], request_type
-                    )()
-        except (AttributeError, IndexError, KeyError):
+                result[request_type] = getattr(
+                    self.dataframe[request_params],
+                    request_type,
+                )()
+        except (AttributeError, IndexError, KeyError) as e:
             if request_type not in {"column", "row"}:
-                raise OutputParserException(
-                    f"Unsupported request type '{request_type}'. \
+                msg = f"Unsupported request type '{request_type}'. \
                         Please check the format instructions."
-                )
-            raise OutputParserException(
-                f"""Requested index {
-                    request_params
-                    if stripped_request_params is None
-                    else stripped_request_params
-                } is out of bounds."""
-            )
+                raise OutputParserException(msg) from e
+            msg = f"""Requested index {
+                request_params
+                if stripped_request_params is None
+                else stripped_request_params
+            } is out of bounds."""
+            raise OutputParserException(msg) from e
 
         return result
 
+    @override
     def get_format_instructions(self) -> str:
         return PANDAS_DATAFRAME_FORMAT_INSTRUCTIONS.format(
-            columns=", ".join(self.dataframe.columns)
+            columns=", ".join(self.dataframe.columns),
         )

langchain/output_parsers/prompts.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
 NAIVE_FIX = """Instructions:
@@ -16,7 +15,7 @@ Error:
 {error}
 --------------
 
-Please try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:"""
+Please try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:"""  # noqa: E501
 
 
 NAIVE_FIX_PROMPT = PromptTemplate.from_template(NAIVE_FIX)

langchain/output_parsers/rail_parser.py

@@ -9,7 +9,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)

langchain/output_parsers/regex.py

@@ -4,12 +4,14 @@ import re
 from typing import Optional
 
 from langchain_core.output_parsers import BaseOutputParser
+from typing_extensions import override
 
 
 class RegexParser(BaseOutputParser[dict[str, str]]):
     """Parse the output of an LLM call using a regex."""
 
     @classmethod
+    @override
     def is_lc_serializable(cls) -> bool:
         return True
 
@@ -30,11 +32,10 @@ class RegexParser(BaseOutputParser[dict[str, str]]):
         match = re.search(self.regex, text)
         if match:
             return {key: match.group(i + 1) for i, key in enumerate(self.output_keys)}
-        else:
-            if self.default_output_key is None:
-                raise ValueError(f"Could not parse output: {text}")
-            else:
-                return {
-                    key: text if key == self.default_output_key else ""
-                    for key in self.output_keys
-                }
+        if self.default_output_key is None:
+            msg = f"Could not parse output: {text}"
+            raise ValueError(msg)
+        return {
+            key: text if key == self.default_output_key else ""
+            for key in self.output_keys
+        }

langchain/output_parsers/regex_dict.py

@@ -28,19 +28,16 @@ class RegexDictParser(BaseOutputParser[dict[str, str]]):
             specific_regex = self.regex_pattern.format(re.escape(expected_format))
             matches = re.findall(specific_regex, text)
             if not matches:
-                raise ValueError(
+                msg = (
                     f"No match found for output key: {output_key} with expected format \
                         {expected_format} on text {text}"
                 )
-            elif len(matches) > 1:
-                raise ValueError(
-                    f"Multiple matches found for output key: {output_key} with \
+                raise ValueError(msg)
+            if len(matches) > 1:
+                msg = f"Multiple matches found for output key: {output_key} with \
                         expected format {expected_format} on text {text}"
-                )
-            elif (
-                self.no_update_value is not None and matches[0] == self.no_update_value
-            ):
+                raise ValueError(msg)
+            if self.no_update_value is not None and matches[0] == self.no_update_value:
                 continue
-            else:
-                result[output_key] = matches[0]
+            result[output_key] = matches[0]
         return result