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

langchain/output_parsers/pandas_dataframe.py

@@ -24,15 +24,17 @@ class PandasDataFrameOutputParser(BaseOutputParser[dict[str, Any]]):
         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]:
         parsed_array: list[Union[int, str]] = []
 
@@ -46,57 +48,52 @@ 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]
 
     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 +124,33 @@ 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
 
     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

@@ -30,11 +30,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

langchain/output_parsers/retry.py

@@ -30,7 +30,7 @@ Please try again:"""
 
 NAIVE_RETRY_PROMPT = PromptTemplate.from_template(NAIVE_COMPLETION_RETRY)
 NAIVE_RETRY_WITH_ERROR_PROMPT = PromptTemplate.from_template(
-    NAIVE_COMPLETION_RETRY_WITH_ERROR
+    NAIVE_COMPLETION_RETRY_WITH_ERROR,
 )
 
 T = TypeVar("T")
@@ -104,25 +104,25 @@ class RetryOutputParser(BaseOutputParser[T]):
         while retries <= self.max_retries:
             try:
                 return self.parser.parse(completion)
-            except OutputParserException as e:
+            except OutputParserException:
                 if retries == self.max_retries:
-                    raise e
+                    raise
+                retries += 1
+                if self.legacy and hasattr(self.retry_chain, "run"):
+                    completion = self.retry_chain.run(
+                        prompt=prompt_value.to_string(),
+                        completion=completion,
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "run"):
-                        completion = self.retry_chain.run(
-                            prompt=prompt_value.to_string(),
-                            completion=completion,
-                        )
-                    else:
-                        completion = self.retry_chain.invoke(
-                            dict(
-                                prompt=prompt_value.to_string(),
-                                completion=completion,
-                            )
-                        )
-
-        raise OutputParserException("Failed to parse")
+                    completion = self.retry_chain.invoke(
+                        {
+                            "prompt": prompt_value.to_string(),
+                            "completion": completion,
+                        },
+                    )
+
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
 
     async def aparse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:
         """Parse the output of an LLM call using a wrapped parser.
@@ -141,29 +141,28 @@ class RetryOutputParser(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(
+                        prompt=prompt_value.to_string(),
+                        completion=completion,
+                        error=repr(e),
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "arun"):
-                        completion = await self.retry_chain.arun(
-                            prompt=prompt_value.to_string(),
-                            completion=completion,
-                            error=repr(e),
-                        )
-                    else:
-                        completion = await self.retry_chain.ainvoke(
-                            dict(
-                                prompt=prompt_value.to_string(),
-                                completion=completion,
-                            )
-                        )
-
-        raise OutputParserException("Failed to parse")
+                    completion = await self.retry_chain.ainvoke(
+                        {
+                            "prompt": prompt_value.to_string(),
+                            "completion": completion,
+                        },
+                    )
+
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
 
     def parse(self, completion: str) -> T:
-        raise NotImplementedError(
-            "This OutputParser can only be called by the `parse_with_prompt` method."
-        )
+        msg = "This OutputParser can only be called by the `parse_with_prompt` method."
+        raise NotImplementedError(msg)
 
     def get_format_instructions(self) -> str:
         return self.parser.get_format_instructions()
@@ -192,7 +191,8 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
     # Should be an LLMChain but we want to avoid top-level imports from langchain.chains
     retry_chain: Annotated[
         Union[
-            RunnableSerializable[RetryWithErrorOutputParserRetryChainInput, str], Any
+            RunnableSerializable[RetryWithErrorOutputParserRetryChainInput, str],
+            Any,
         ],
         SkipValidation(),
     ]
@@ -232,25 +232,25 @@ class RetryWithErrorOutputParser(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(
+                        prompt=prompt_value.to_string(),
+                        completion=completion,
+                        error=repr(e),
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "run"):
-                        completion = self.retry_chain.run(
-                            prompt=prompt_value.to_string(),
-                            completion=completion,
-                            error=repr(e),
-                        )
-                    else:
-                        completion = self.retry_chain.invoke(
-                            dict(
-                                completion=completion,
-                                prompt=prompt_value.to_string(),
-                                error=repr(e),
-                            )
-                        )
-
-        raise OutputParserException("Failed to parse")
+                    completion = self.retry_chain.invoke(
+                        {
+                            "completion": completion,
+                            "prompt": prompt_value.to_string(),
+                            "error": repr(e),
+                        },
+                    )
+
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
 
     async def aparse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:
         retries = 0
@@ -260,30 +260,29 @@ class RetryWithErrorOutputParser(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(
+                        prompt=prompt_value.to_string(),
+                        completion=completion,
+                        error=repr(e),
+                    )
                 else:
-                    retries += 1
-                    if self.legacy and hasattr(self.retry_chain, "arun"):
-                        completion = await self.retry_chain.arun(
-                            prompt=prompt_value.to_string(),
-                            completion=completion,
-                            error=repr(e),
-                        )
-                    else:
-                        completion = await self.retry_chain.ainvoke(
-                            dict(
-                                prompt=prompt_value.to_string(),
-                                completion=completion,
-                                error=repr(e),
-                            )
-                        )
-
-        raise OutputParserException("Failed to parse")
+                    completion = await self.retry_chain.ainvoke(
+                        {
+                            "prompt": prompt_value.to_string(),
+                            "completion": completion,
+                            "error": repr(e),
+                        },
+                    )
+
+        msg = "Failed to parse"
+        raise OutputParserException(msg)
 
     def parse(self, completion: str) -> T:
-        raise NotImplementedError(
-            "This OutputParser can only be called by the `parse_with_prompt` method."
-        )
+        msg = "This OutputParser can only be called by the `parse_with_prompt` method."
+        raise NotImplementedError(msg)
 
     def get_format_instructions(self) -> str:
         return self.parser.get_format_instructions()

langchain/output_parsers/structured.py

@@ -27,7 +27,9 @@ class ResponseSchema(BaseModel):
 
 def _get_sub_string(schema: ResponseSchema) -> str:
     return line_template.format(
-        name=schema.name, description=schema.description, type=schema.type
+        name=schema.name,
+        description=schema.description,
+        type=schema.type,
     )
 
 
@@ -39,11 +41,15 @@ class StructuredOutputParser(BaseOutputParser[dict[str, Any]]):
 
     @classmethod
     def from_response_schemas(
-        cls, response_schemas: list[ResponseSchema]
+        cls,
+        response_schemas: list[ResponseSchema],
     ) -> StructuredOutputParser:
         return cls(response_schemas=response_schemas)
 
-    def get_format_instructions(self, only_json: bool = False) -> str:
+    def get_format_instructions(
+        self,
+        only_json: bool = False,  # noqa: FBT001,FBT002
+    ) -> str:
         """Get format instructions for the output parser.
 
         example:
@@ -85,12 +91,11 @@ class StructuredOutputParser(BaseOutputParser[dict[str, Any]]):
                 will be returned, without the introducing text. Defaults to False.
         """
         schema_str = "\n".join(
-            [_get_sub_string(schema) for schema in self.response_schemas]
+            [_get_sub_string(schema) for schema in self.response_schemas],
         )
         if only_json:
             return STRUCTURED_FORMAT_SIMPLE_INSTRUCTIONS.format(format=schema_str)
-        else:
-            return STRUCTURED_FORMAT_INSTRUCTIONS.format(format=schema_str)
+        return STRUCTURED_FORMAT_INSTRUCTIONS.format(format=schema_str)
 
     def parse(self, text: str) -> dict[str, Any]:
         expected_keys = [rs.name for rs in self.response_schemas]

langchain/output_parsers/yaml.py

@@ -18,27 +18,23 @@ class YamlOutputParser(BaseOutputParser[T]):
     pydantic_object: type[T]
     """The pydantic model to parse."""
     pattern: re.Pattern = re.compile(
-        r"^```(?:ya?ml)?(?P<yaml>[^`]*)", re.MULTILINE | re.DOTALL
+        r"^```(?:ya?ml)?(?P<yaml>[^`]*)",
+        re.MULTILINE | re.DOTALL,
     )
-    """Regex pattern to match yaml code blocks 
+    """Regex pattern to match yaml code blocks
     within triple backticks with optional yaml or yml prefix."""
 
     def parse(self, text: str) -> T:
         try:
             # Greedy search for 1st yaml candidate.
             match = re.search(self.pattern, text.strip())
-            yaml_str = ""
-            if match:
-                yaml_str = match.group("yaml")
-            else:
-                # If no backticks were present, try to parse the entire output as yaml.
-                yaml_str = text
+            # If no backticks were present, try to parse the entire output as yaml.
+            yaml_str = match.group("yaml") if match else text
 
             json_object = yaml.safe_load(yaml_str)
             if hasattr(self.pydantic_object, "model_validate"):
                 return self.pydantic_object.model_validate(json_object)
-            else:
-                return self.pydantic_object.parse_obj(json_object)
+            return self.pydantic_object.parse_obj(json_object)
 
         except (yaml.YAMLError, ValidationError) as e:
             name = self.pydantic_object.__name__
@@ -47,7 +43,15 @@ class YamlOutputParser(BaseOutputParser[T]):
 
     def get_format_instructions(self) -> str:
         # Copy schema to avoid altering original Pydantic schema.
-        schema = {k: v for k, v in self.pydantic_object.schema().items()}
+        if hasattr(self.pydantic_object, "model_json_schema"):
+            # Pydantic v2
+            schema = dict(self.pydantic_object.model_json_schema().items())
+        elif hasattr(self.pydantic_object, "schema"):
+            # Pydantic v1
+            schema = dict(self.pydantic_object.schema().items())
+        else:
+            msg = "Pydantic object must have either model_json_schema or schema method"
+            raise ValueError(msg)
 
         # Remove extraneous fields.
         reduced_schema = schema

langchain/prompts/__init__.py

@@ -65,7 +65,9 @@ if TYPE_CHECKING:
 # Used to consolidate logic for raising deprecation warnings and
 # handling optional imports.
 MODULE_LOOKUP = {
-    "NGramOverlapExampleSelector": "langchain_community.example_selectors.ngram_overlap"
+    "NGramOverlapExampleSelector": (
+        "langchain_community.example_selectors.ngram_overlap"
+    ),
 }
 
 _import_attribute = create_importer(__file__, module_lookup=MODULE_LOOKUP)
@@ -82,6 +84,7 @@ __all__ = [
     "BasePromptTemplate",
     "ChatMessagePromptTemplate",
     "ChatPromptTemplate",
+    "FewShotChatMessagePromptTemplate",
     "FewShotPromptTemplate",
     "FewShotPromptWithTemplates",
     "HumanMessagePromptTemplate",
@@ -90,11 +93,10 @@ __all__ = [
     "MessagesPlaceholder",
     "NGramOverlapExampleSelector",
     "PipelinePromptTemplate",
+    "Prompt",
     "PromptTemplate",
     "SemanticSimilarityExampleSelector",
     "StringPromptTemplate",
     "SystemMessagePromptTemplate",
     "load_prompt",
-    "FewShotChatMessagePromptTemplate",
-    "Prompt",
 ]

langchain/prompts/base.py

@@ -10,12 +10,12 @@ from langchain_core.prompts import (
 from langchain_core.prompts.string import _get_jinja2_variables_from_template
 
 __all__ = [
-    "jinja2_formatter",
-    "validate_jinja2",
-    "check_valid_template",
-    "get_template_variables",
-    "StringPromptTemplate",
     "BasePromptTemplate",
+    "StringPromptTemplate",
     "StringPromptValue",
     "_get_jinja2_variables_from_template",
+    "check_valid_template",
+    "get_template_variables",
+    "jinja2_formatter",
+    "validate_jinja2",
 ]

langchain/prompts/chat.py

@@ -16,22 +16,22 @@ from langchain_core.prompts.chat import (
 )
 
 __all__ = [
+    "AIMessagePromptTemplate",
+    "BaseChatPromptTemplate",
     "BaseMessagePromptTemplate",
-    "MessagesPlaceholder",
     "BaseStringMessagePromptTemplate",
     "ChatMessagePromptTemplate",
-    "HumanMessagePromptTemplate",
-    "AIMessagePromptTemplate",
-    "SystemMessagePromptTemplate",
-    "BaseChatPromptTemplate",
     "ChatPromptTemplate",
     "ChatPromptValue",
     "ChatPromptValueConcrete",
-    "_convert_to_message",
-    "_create_template_from_message_type",
-    "MessagePromptTemplateT",
+    "HumanMessagePromptTemplate",
     "MessageLike",
     "MessageLikeRepresentation",
+    "MessagePromptTemplateT",
+    "MessagesPlaceholder",
+    "SystemMessagePromptTemplate",
+    "_convert_to_message",
+    "_create_template_from_message_type",
 ]
 
 from langchain_core.prompts.message import BaseMessagePromptTemplate

langchain/prompts/example_selector/__init__.py

@@ -21,7 +21,9 @@ if TYPE_CHECKING:
 # Used to consolidate logic for raising deprecation warnings and
 # handling optional imports.
 DEPRECATED_LOOKUPS = {
-    "NGramOverlapExampleSelector": "langchain_community.example_selectors.ngram_overlap"
+    "NGramOverlapExampleSelector": (
+        "langchain_community.example_selectors.ngram_overlap"
+    ),
 }
 
 _import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUPS)

langchain/prompts/example_selector/semantic_similarity.py

@@ -5,7 +5,7 @@ from langchain_core.example_selectors.semantic_similarity import (
 )
 
 __all__ = [
-    "sorted_values",
-    "SemanticSimilarityExampleSelector",
     "MaxMarginalRelevanceExampleSelector",
+    "SemanticSimilarityExampleSelector",
+    "sorted_values",
 ]

langchain/prompts/few_shot.py

@@ -5,7 +5,7 @@ from langchain_core.prompts.few_shot import (
 )
 
 __all__ = [
-    "FewShotPromptTemplate",
     "FewShotChatMessagePromptTemplate",
+    "FewShotPromptTemplate",
     "_FewShotPromptTemplateMixin",
 ]

langchain/prompts/loading.py

@@ -11,13 +11,13 @@ from langchain_core.prompts.loading import (
 from langchain_core.utils.loading import try_load_from_hub
 
 __all__ = [
-    "load_prompt_from_config",
-    "load_prompt",
-    "try_load_from_hub",
     "_load_examples",
     "_load_few_shot_prompt",
     "_load_output_parser",
     "_load_prompt",
     "_load_prompt_from_file",
     "_load_template",
+    "load_prompt",
+    "load_prompt_from_config",
+    "try_load_from_hub",
 ]