langchain 0.4.0.dev0__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

langchain/output_parsers/enum.py

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

langchain/output_parsers/ernie_functions.py

@@ -1,45 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.output_parsers.ernie_functions import (
-        JsonKeyOutputFunctionsParser,
-        JsonOutputFunctionsParser,
-        OutputFunctionsParser,
-        PydanticAttrOutputFunctionsParser,
-        PydanticOutputFunctionsParser,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "JsonKeyOutputFunctionsParser": (
-        "langchain_community.output_parsers.ernie_functions"
-    ),
-    "JsonOutputFunctionsParser": "langchain_community.output_parsers.ernie_functions",
-    "OutputFunctionsParser": "langchain_community.output_parsers.ernie_functions",
-    "PydanticAttrOutputFunctionsParser": (
-        "langchain_community.output_parsers.ernie_functions"
-    ),
-    "PydanticOutputFunctionsParser": (
-        "langchain_community.output_parsers.ernie_functions"
-    ),
-}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "JsonKeyOutputFunctionsParser",
-    "JsonOutputFunctionsParser",
-    "OutputFunctionsParser",
-    "PydanticAttrOutputFunctionsParser",
-    "PydanticOutputFunctionsParser",
-]

langchain/output_parsers/fix.py

@@ -1,155 +0,0 @@
-from __future__ import annotations
-
-from typing import Annotated, Any, TypeVar, Union
-
-from langchain_core.exceptions import OutputParserException
-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, override
-
-from langchain.output_parsers.prompts import NAIVE_FIX_PROMPT
-
-T = TypeVar("T")
-
-
-class OutputFixingParserRetryChainInput(TypedDict, total=False):
-    """Input for the retry chain of the OutputFixingParser."""
-
-    instructions: str
-    completion: str
-    error: str
-
-
-class OutputFixingParser(BaseOutputParser[T]):
-    """Wrap a parser and try to fix parsing errors."""
-
-    @classmethod
-    @override
-    def is_lc_serializable(cls) -> bool:
-        return True
-
-    parser: Annotated[Any, SkipValidation()]
-    """The parser to use to parse the output."""
-    # Should be an LLMChain but we want to avoid top-level imports from langchain.chains
-    retry_chain: Annotated[
-        Union[RunnableSerializable[OutputFixingParserRetryChainInput, str], Any],
-        SkipValidation(),
-    ]
-    """The RunnableSerializable to use to retry the completion (Legacy: LLMChain)."""
-    max_retries: int = 1
-    """The maximum number of times to retry the parse."""
-    legacy: bool = True
-    """Whether to use the run or arun method of the retry_chain."""
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: Runnable,
-        parser: BaseOutputParser[T],
-        prompt: BasePromptTemplate = NAIVE_FIX_PROMPT,
-        max_retries: int = 1,
-    ) -> OutputFixingParser[T]:
-        """Create an OutputFixingParser from a language model and a parser.
-
-        Args:
-            llm: llm to use for fixing
-            parser: parser to use for parsing
-            prompt: prompt to use for fixing
-            max_retries: Maximum number of retries to parse.
-
-        Returns:
-            OutputFixingParser
-        """
-        chain = prompt | llm | StrOutputParser()
-        return cls(parser=parser, retry_chain=chain, max_retries=max_retries)
-
-    @override
-    def parse(self, completion: str) -> T:
-        retries = 0
-
-        while retries <= self.max_retries:
-            try:
-                return self.parser.parse(completion)
-            except OutputParserException as e:
-                if retries == self.max_retries:
-                    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:
-                    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),
-                            },
-                        )
-
-        msg = "Failed to parse"
-        raise OutputParserException(msg)
-
-    @override
-    async def aparse(self, completion: str) -> T:
-        retries = 0
-
-        while retries <= self.max_retries:
-            try:
-                return await self.parser.aparse(completion)
-            except OutputParserException as e:
-                if retries == self.max_retries:
-                    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:
-                    try:
-                        completion = await self.retry_chain.ainvoke(
-                            {
-                                "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(
-                            {
-                                "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()
-
-    @property
-    def _type(self) -> str:
-        return "output_fixing"
-
-    @property
-    @override
-    def OutputType(self) -> type[T]:
-        return self.parser.OutputType

langchain/output_parsers/format_instructions.py

@@ -1,79 +0,0 @@
-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
-{{
-{format}
-}}
-```"""
-
-
-PYDANTIC_FORMAT_INSTRUCTIONS = """The output should be formatted as a JSON instance that conforms to the JSON schema below.
-
-As an example, for the schema {{"properties": {{"foo": {{"title": "Foo", "description": "a list of strings", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}
-the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of the schema. The object {{"properties": {{"foo": ["bar", "baz"]}}}} is not well-formatted.
-
-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.
-
-# Examples
-## Schema
-```
-{{"title": "Players", "description": "A list of players", "type": "array", "items": {{"$ref": "#/definitions/Player"}}, "definitions": {{"Player": {{"title": "Player", "type": "object", "properties": {{"name": {{"title": "Name", "description": "Player name", "type": "string"}}, "avg": {{"title": "Avg", "description": "Batting average", "type": "number"}}}}, "required": ["name", "avg"]}}}}}}
-```
-## Well formatted instance
-```
-- name: John Doe
-  avg: 0.3
-- name: Jane Maxfield
-  avg: 1.4
-```
-
-## Schema
-```
-{{"properties": {{"habit": {{ "description": "A common daily habit", "type": "string" }}, "sustainable_alternative": {{ "description": "An environmentally friendly alternative to the habit", "type": "string"}}}}, "required": ["habit", "sustainable_alternative"]}}
-```
-## Well formatted 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:
-```
-{schema}
-```
-
-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.
-1. The column names are limited to the possible columns below.
-2. Arrays must either be a comma-separated list of numbers formatted as [1,3,5], or it must be in range of numbers formatted as [0..4].
-3. Remember that arrays are optional and not necessarily required.
-4. If the column is not in the possible columns or the operation is not a valid Pandas DataFrame operation, return why it is invalid as a sentence starting with either "Invalid column" or "Invalid operation".
-
-As an example, for the formats:
-1. String "column:num_legs" is a well-formatted instance which gets the column num_legs, where num_legs is a possible column.
-2. String "row:1" is a well-formatted instance which gets row 1.
-3. String "column:num_legs[1,2]" is a well-formatted instance which gets the column num_legs for rows 1 and 2, where num_legs is a possible column.
-4. String "row:1[num_legs]" is a well-formatted instance which gets row 1, but for just column num_legs, where num_legs is a possible column.
-5. String "mean:num_legs[1..3]" is a well-formatted instance which takes the mean of num_legs from rows 1 to 3, where num_legs is a possible column and mean is a valid Pandas DataFrame operation.
-6. String "do_something:num_legs" is a badly-formatted instance, where do_something is not a valid Pandas DataFrame operation.
-7. String "mean:invalid_col" is a badly-formatted instance, where invalid_col is not a possible column.
-
-Here are the possible columns:
-```
-{columns}
-```
-"""  # noqa: E501

langchain/output_parsers/json.py

@@ -1,15 +0,0 @@
-from langchain_core.output_parsers.json import (
-    SimpleJsonOutputParser,
-)
-from langchain_core.utils.json import (
-    parse_and_check_json_markdown,
-    parse_json_markdown,
-    parse_partial_json,
-)
-
-__all__ = [
-    "SimpleJsonOutputParser",
-    "parse_and_check_json_markdown",
-    "parse_json_markdown",
-    "parse_partial_json",
-]

langchain/output_parsers/list.py

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

langchain/output_parsers/loading.py

@@ -1,22 +0,0 @@
-from langchain.output_parsers.regex import RegexParser
-
-
-def load_output_parser(config: dict) -> dict:
-    """Load an output parser.
-
-    Args:
-        config: config dict
-
-    Returns:
-        config dict with output parser loaded
-    """
-    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

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

langchain/output_parsers/openai_tools.py

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

langchain/output_parsers/pandas_dataframe.py

@@ -1,171 +0,0 @@
-import re
-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,
-)
-
-
-class PandasDataFrameOutputParser(BaseOutputParser[dict[str, Any]]):
-    """Parse an output using Pandas DataFrame format."""
-
-    """The Pandas DataFrame to parse."""
-    dataframe: Any
-
-    @field_validator("dataframe")
-    @classmethod
-    def _validate_dataframe(cls, val: Any) -> Any:
-        import pandas as pd
-
-        if issubclass(type(val), pd.DataFrame):
-            return val
-        if pd.DataFrame(val).empty:
-            msg = "DataFrame cannot be empty."
-            raise ValueError(msg)
-
-        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,
-    ) -> 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]
-        if re.match(r"\[\d+(,\s*\d+)*\]", array):
-            parsed_array = [int(i) for i in re.findall(r"\d+", array)]
-        # Check if the format is [1..5]
-        elif re.match(r"\[(\d+)\.\.(\d+)\]", array):
-            match = re.match(r"\[(\d+)\.\.(\d+)\]", array)
-            if match:
-                start, end = map(int, match.groups())
-                parsed_array = list(range(start, end + 1))
-            else:
-                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:
-                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:
-            msg = f"Invalid array format in '{original_request_params}'. \
-                    Please check the format instructions."
-            raise OutputParserException(msg)
-        if (
-            isinstance(parsed_array[0], int)
-            and parsed_array[-1] > self.dataframe.index.max()
-        ):
-            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:  # 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"}:
-                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,
-                )
-                if request_type == "column":
-                    filtered_df = self.dataframe[
-                        self.dataframe.index.isin(parsed_array)
-                    ]
-                    if len(parsed_array) == 1:
-                        result[stripped_request_params] = filtered_df[
-                            stripped_request_params
-                        ].iloc[parsed_array[0]]
-                    else:
-                        result[stripped_request_params] = filtered_df[
-                            stripped_request_params
-                        ]
-                elif request_type == "row":
-                    filtered_df = self.dataframe[
-                        self.dataframe.columns.intersection(parsed_array)
-                    ]
-                    if len(parsed_array) == 1:
-                        result[stripped_request_params] = filtered_df.iloc[
-                            int(stripped_request_params)
-                        ][parsed_array[0]]
-                    else:
-                        result[stripped_request_params] = filtered_df.iloc[
-                            int(stripped_request_params)
-                        ]
-                else:
-                    filtered_df = self.dataframe[
-                        self.dataframe.index.isin(parsed_array)
-                    ]
-                    result[request_type] = getattr(
-                        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:
-                result[request_type] = getattr(
-                    self.dataframe[request_params],
-                    request_type,
-                )()
-        except (AttributeError, IndexError, KeyError) as e:
-            if request_type not in {"column", "row"}:
-                msg = f"Unsupported request type '{request_type}'. \
-                        Please check the format instructions."
-                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),
-        )

langchain/output_parsers/prompts.py

@@ -1,21 +0,0 @@
-from langchain_core.prompts.prompt import PromptTemplate
-
-NAIVE_FIX = """Instructions:
---------------
-{instructions}
---------------
-Completion:
---------------
-{completion}
---------------
-
-Above, the Completion did not satisfy the constraints given in the Instructions.
-Error:
---------------
-{error}
---------------
-
-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/pydantic.py

@@ -1,3 +0,0 @@
-from langchain_core.output_parsers import PydanticOutputParser
-
-__all__ = ["PydanticOutputParser"]

langchain/output_parsers/rail_parser.py

@@ -1,25 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.output_parsers.rail_parser import GuardrailsOutputParser
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "GuardrailsOutputParser": "langchain_community.output_parsers.rail_parser",
-}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "GuardrailsOutputParser",
-]

langchain/output_parsers/regex.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-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
-
-    regex: str
-    """The regex to use to parse the output."""
-    output_keys: list[str]
-    """The keys to use for the output."""
-    default_output_key: Optional[str] = None
-    """The default key to use for the output."""
-
-    @property
-    def _type(self) -> str:
-        """Return the type key."""
-        return "regex_parser"
-
-    def parse(self, text: str) -> dict[str, str]:
-        """Parse the output of an LLM call."""
-        match = re.search(self.regex, text)
-        if match:
-            return {key: match.group(i + 1) for i, key in enumerate(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
-        }