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

langchain/output_parsers/regex_dict.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Optional
-
-from langchain_core.output_parsers import BaseOutputParser
-
-
-class RegexDictParser(BaseOutputParser[dict[str, str]]):
-    """Parse the output of an LLM call into a Dictionary using a regex."""
-
-    regex_pattern: str = r"{}:\s?([^.'\n']*)\.?"  # : :meta private:
-    """The regex pattern to use to parse the output."""
-    output_key_to_format: dict[str, str]
-    """The keys to use for the output."""
-    no_update_value: Optional[str] = None
-    """The default key to use for the output."""
-
-    @property
-    def _type(self) -> str:
-        """Return the type key."""
-        return "regex_dict_parser"
-
-    def parse(self, text: str) -> dict[str, str]:
-        """Parse the output of an LLM call."""
-        result = {}
-        for output_key, expected_format in self.output_key_to_format.items():
-            specific_regex = self.regex_pattern.format(re.escape(expected_format))
-            matches = re.findall(specific_regex, text)
-            if not matches:
-                msg = (
-                    f"No match found for output key: {output_key} with expected format \
-                        {expected_format} on text {text}"
-                )
-                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}"
-                raise ValueError(msg)
-            if self.no_update_value is not None and matches[0] == self.no_update_value:
-                continue
-            result[output_key] = matches[0]
-        return result

langchain/output_parsers/retry.py

@@ -1,316 +0,0 @@
-from __future__ import annotations
-
-from typing import Annotated, Any, TypeVar, Union
-
-from langchain_core.exceptions import OutputParserException
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import BaseOutputParser, StrOutputParser
-from langchain_core.prompt_values import PromptValue
-from langchain_core.prompts import BasePromptTemplate, PromptTemplate
-from langchain_core.runnables import RunnableSerializable
-from pydantic import SkipValidation
-from typing_extensions import TypedDict, override
-
-NAIVE_COMPLETION_RETRY = """Prompt:
-{prompt}
-Completion:
-{completion}
-
-Above, the Completion did not satisfy the constraints given in the Prompt.
-Please try again:"""
-
-NAIVE_COMPLETION_RETRY_WITH_ERROR = """Prompt:
-{prompt}
-Completion:
-{completion}
-
-Above, the Completion did not satisfy the constraints given in the Prompt.
-Details: {error}
-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,
-)
-
-T = TypeVar("T")
-
-
-class RetryOutputParserRetryChainInput(TypedDict):
-    """Retry chain input for RetryOutputParser."""
-
-    prompt: str
-    completion: str
-
-
-class RetryWithErrorOutputParserRetryChainInput(TypedDict):
-    """Retry chain input for RetryWithErrorOutputParser."""
-
-    prompt: str
-    completion: str
-    error: str
-
-
-class RetryOutputParser(BaseOutputParser[T]):
-    """Wrap a parser and try to fix parsing errors.
-
-    Does this by passing the original prompt and the completion to another
-    LLM, and telling it the completion did not satisfy criteria in the prompt.
-    """
-
-    parser: Annotated[BaseOutputParser[T], 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[RetryOutputParserRetryChainInput, 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: BaseLanguageModel,
-        parser: BaseOutputParser[T],
-        prompt: BasePromptTemplate = NAIVE_RETRY_PROMPT,
-        max_retries: int = 1,
-    ) -> RetryOutputParser[T]:
-        """Create an RetryOutputParser 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:
-            RetryOutputParser
-        """
-        chain = prompt | llm | StrOutputParser()
-        return cls(parser=parser, retry_chain=chain, max_retries=max_retries)
-
-    def parse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:
-        """Parse the output of an LLM call using a wrapped parser.
-
-        Args:
-            completion: The chain completion to parse.
-            prompt_value: The prompt to use to parse the completion.
-
-        Returns:
-            The parsed completion.
-        """
-        retries = 0
-
-        while retries <= self.max_retries:
-            try:
-                return self.parser.parse(completion)
-            except OutputParserException:
-                if retries == self.max_retries:
-                    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:
-                    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.
-
-        Args:
-            completion: The chain completion to parse.
-            prompt_value: The prompt to use to parse the completion.
-
-        Returns:
-            The parsed completion.
-        """
-        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(
-                        prompt=prompt_value.to_string(),
-                        completion=completion,
-                        error=repr(e),
-                    )
-                else:
-                    completion = await self.retry_chain.ainvoke(
-                        {
-                            "prompt": prompt_value.to_string(),
-                            "completion": completion,
-                        },
-                    )
-
-        msg = "Failed to parse"
-        raise OutputParserException(msg)
-
-    @override
-    def parse(self, completion: str) -> T:
-        msg = "This OutputParser can only be called by the `parse_with_prompt` method."
-        raise NotImplementedError(msg)
-
-    @override
-    def get_format_instructions(self) -> str:
-        return self.parser.get_format_instructions()
-
-    @property
-    def _type(self) -> str:
-        return "retry"
-
-    @property
-    @override
-    def OutputType(self) -> type[T]:
-        return self.parser.OutputType
-
-
-class RetryWithErrorOutputParser(BaseOutputParser[T]):
-    """Wrap a parser and try to fix parsing errors.
-
-    Does this by passing the original prompt, the completion, AND the error
-    that was raised to another language model and telling it that the completion
-    did not work, and raised the given error. Differs from RetryOutputParser
-    in that this implementation provides the error that was raised back to the
-    LLM, which in theory should give it more information on how to fix it.
-    """
-
-    parser: Annotated[BaseOutputParser[T], 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[RetryWithErrorOutputParserRetryChainInput, 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: BaseLanguageModel,
-        parser: BaseOutputParser[T],
-        prompt: BasePromptTemplate = NAIVE_RETRY_WITH_ERROR_PROMPT,
-        max_retries: int = 1,
-    ) -> RetryWithErrorOutputParser[T]:
-        """Create a RetryWithErrorOutputParser from an LLM.
-
-        Args:
-            llm: The LLM to use to retry the completion.
-            parser: The parser to use to parse the output.
-            prompt: The prompt to use to retry the completion.
-            max_retries: The maximum number of times to retry the completion.
-
-        Returns:
-            A RetryWithErrorOutputParser.
-        """
-        chain = prompt | llm | StrOutputParser()
-        return cls(parser=parser, retry_chain=chain, max_retries=max_retries)
-
-    @override
-    def parse_with_prompt(self, completion: str, prompt_value: PromptValue) -> 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(
-                        prompt=prompt_value.to_string(),
-                        completion=completion,
-                        error=repr(e),
-                    )
-                else:
-                    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:
-        """Parse the output of an LLM call using a wrapped parser.
-
-        Args:
-            completion: The chain completion to parse.
-            prompt_value: The prompt to use to parse the completion.
-
-        Returns:
-            The parsed completion.
-        """
-        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(
-                        prompt=prompt_value.to_string(),
-                        completion=completion,
-                        error=repr(e),
-                    )
-                else:
-                    completion = await self.retry_chain.ainvoke(
-                        {
-                            "prompt": prompt_value.to_string(),
-                            "completion": completion,
-                            "error": repr(e),
-                        },
-                    )
-
-        msg = "Failed to parse"
-        raise OutputParserException(msg)
-
-    @override
-    def parse(self, completion: str) -> T:
-        msg = "This OutputParser can only be called by the `parse_with_prompt` method."
-        raise NotImplementedError(msg)
-
-    @override
-    def get_format_instructions(self) -> str:
-        return self.parser.get_format_instructions()
-
-    @property
-    def _type(self) -> str:
-        return "retry_with_error"
-
-    @property
-    @override
-    def OutputType(self) -> type[T]:
-        return self.parser.OutputType

langchain/output_parsers/structured.py

@@ -1,116 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from langchain_core.output_parsers import BaseOutputParser
-from langchain_core.output_parsers.json import parse_and_check_json_markdown
-from pydantic import BaseModel
-from typing_extensions import override
-
-from langchain.output_parsers.format_instructions import (
-    STRUCTURED_FORMAT_INSTRUCTIONS,
-    STRUCTURED_FORMAT_SIMPLE_INSTRUCTIONS,
-)
-
-line_template = '\t"{name}": {type}  // {description}'
-
-
-class ResponseSchema(BaseModel):
-    """Schema for a response from a structured output parser."""
-
-    name: str
-    """The name of the schema."""
-    description: str
-    """The description of the schema."""
-    type: str = "string"
-    """The type of the response."""
-
-
-def _get_sub_string(schema: ResponseSchema) -> str:
-    return line_template.format(
-        name=schema.name,
-        description=schema.description,
-        type=schema.type,
-    )
-
-
-class StructuredOutputParser(BaseOutputParser[dict[str, Any]]):
-    """Parse the output of an LLM call to a structured output."""
-
-    response_schemas: list[ResponseSchema]
-    """The schemas for the response."""
-
-    @classmethod
-    def from_response_schemas(
-        cls,
-        response_schemas: list[ResponseSchema],
-    ) -> StructuredOutputParser:
-        """Create a StructuredOutputParser from a list of ResponseSchema.
-
-        Args:
-            response_schemas: The schemas for the response.
-
-        Returns:
-            An instance of StructuredOutputParser.
-        """
-        return cls(response_schemas=response_schemas)
-
-    def get_format_instructions(
-        self,
-        only_json: bool = False,  # noqa: FBT001,FBT002
-    ) -> str:
-        """Get format instructions for the output parser.
-
-        example:
-        ```python
-        from langchain.output_parsers.structured import (
-            StructuredOutputParser, ResponseSchema
-        )
-
-        response_schemas = [
-            ResponseSchema(
-                name="foo",
-                description="a list of strings",
-                type="List[string]"
-                ),
-            ResponseSchema(
-                name="bar",
-                description="a string",
-                type="string"
-                ),
-        ]
-
-        parser = StructuredOutputParser.from_response_schemas(response_schemas)
-
-        print(parser.get_format_instructions())  # noqa: T201
-
-        output:
-        # The output should be a Markdown code snippet formatted in the following
-        # schema, including the leading and trailing "```json" and "```":
-        #
-        # ```json
-        # {
-        #     "foo": List[string]  // a list of strings
-        #     "bar": string  // a string
-        # }
-        # ```
-
-        Args:
-            only_json (bool): If True, only the json in the Markdown code snippet
-                will be returned, without the introducing text. Defaults to False.
-        """
-        schema_str = "\n".join(
-            [_get_sub_string(schema) for schema in self.response_schemas],
-        )
-        if only_json:
-            return STRUCTURED_FORMAT_SIMPLE_INSTRUCTIONS.format(format=schema_str)
-        return STRUCTURED_FORMAT_INSTRUCTIONS.format(format=schema_str)
-
-    @override
-    def parse(self, text: str) -> dict[str, Any]:
-        expected_keys = [rs.name for rs in self.response_schemas]
-        return parse_and_check_json_markdown(text, expected_keys)
-
-    @property
-    def _type(self) -> str:
-        return "structured"

langchain/output_parsers/xml.py

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

langchain/output_parsers/yaml.py

@@ -1,77 +0,0 @@
-import json
-import re
-from typing import TypeVar
-
-import yaml
-from langchain_core.exceptions import OutputParserException
-from langchain_core.output_parsers import BaseOutputParser
-from pydantic import BaseModel, ValidationError
-from typing_extensions import override
-
-from langchain.output_parsers.format_instructions import YAML_FORMAT_INSTRUCTIONS
-
-T = TypeVar("T", bound=BaseModel)
-
-
-class YamlOutputParser(BaseOutputParser[T]):
-    """Parse YAML output using a pydantic model."""
-
-    pydantic_object: type[T]
-    """The pydantic model to parse."""
-    pattern: re.Pattern = re.compile(
-        r"^```(?:ya?ml)?(?P<yaml>[^`]*)",
-        re.MULTILINE | re.DOTALL,
-    )
-    """Regex pattern to match yaml code blocks
-    within triple backticks with optional yaml or yml prefix."""
-
-    @override
-    def parse(self, text: str) -> T:
-        try:
-            # Greedy search for 1st yaml candidate.
-            match = re.search(self.pattern, text.strip())
-            # 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)
-            return self.pydantic_object.parse_obj(json_object)
-
-        except (yaml.YAMLError, ValidationError) as e:
-            name = self.pydantic_object.__name__
-            msg = f"Failed to parse {name} from completion {text}. Got: {e}"
-            raise OutputParserException(msg, llm_output=text) from e
-
-    @override
-    def get_format_instructions(self) -> str:
-        # Copy schema to avoid altering original Pydantic schema.
-        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
-        if "title" in reduced_schema:
-            del reduced_schema["title"]
-        if "type" in reduced_schema:
-            del reduced_schema["type"]
-        # Ensure yaml in context is well-formed with double quotes.
-        schema_str = json.dumps(reduced_schema)
-
-        return YAML_FORMAT_INSTRUCTIONS.format(schema=schema_str)
-
-    @property
-    def _type(self) -> str:
-        return "yaml"
-
-    @property
-    @override
-    def OutputType(self) -> type[T]:
-        return self.pydantic_object

langchain/prompts/__init__.py

@@ -1,102 +0,0 @@
-"""**Prompt** is the input to the model.
-
-Prompt is often constructed
-from multiple components. Prompt classes and functions make constructing
- and working with prompts easy.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BasePromptTemplate --> PipelinePromptTemplate
-                           StringPromptTemplate --> PromptTemplate
-                                                    FewShotPromptTemplate
-                                                    FewShotPromptWithTemplates
-                           BaseChatPromptTemplate --> AutoGPTPrompt
-                                                      ChatPromptTemplate --> AgentScratchPadChatPromptTemplate
-
-
-
-    BaseMessagePromptTemplate --> MessagesPlaceholder
-                                  BaseStringMessagePromptTemplate --> ChatMessagePromptTemplate
-                                                                      HumanMessagePromptTemplate
-                                                                      AIMessagePromptTemplate
-                                                                      SystemMessagePromptTemplate
-
-    PromptValue --> StringPromptValue
-                    ChatPromptValue
-
-"""  # noqa: E501
-
-from typing import TYPE_CHECKING, Any
-
-from langchain_core.example_selectors import (
-    LengthBasedExampleSelector,
-    MaxMarginalRelevanceExampleSelector,
-    SemanticSimilarityExampleSelector,
-)
-from langchain_core.prompts import (
-    AIMessagePromptTemplate,
-    BaseChatPromptTemplate,
-    BasePromptTemplate,
-    ChatMessagePromptTemplate,
-    ChatPromptTemplate,
-    FewShotChatMessagePromptTemplate,
-    FewShotPromptTemplate,
-    FewShotPromptWithTemplates,
-    HumanMessagePromptTemplate,
-    MessagesPlaceholder,
-    PipelinePromptTemplate,
-    PromptTemplate,
-    StringPromptTemplate,
-    SystemMessagePromptTemplate,
-    load_prompt,
-)
-
-from langchain._api import create_importer
-from langchain.prompts.prompt import Prompt
-
-if TYPE_CHECKING:
-    from langchain_community.example_selectors.ngram_overlap import (
-        NGramOverlapExampleSelector,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-MODULE_LOOKUP = {
-    "NGramOverlapExampleSelector": (
-        "langchain_community.example_selectors.ngram_overlap"
-    ),
-}
-
-_import_attribute = create_importer(__file__, module_lookup=MODULE_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "AIMessagePromptTemplate",
-    "BaseChatPromptTemplate",
-    "BasePromptTemplate",
-    "ChatMessagePromptTemplate",
-    "ChatPromptTemplate",
-    "FewShotChatMessagePromptTemplate",
-    "FewShotPromptTemplate",
-    "FewShotPromptWithTemplates",
-    "HumanMessagePromptTemplate",
-    "LengthBasedExampleSelector",
-    "MaxMarginalRelevanceExampleSelector",
-    "MessagesPlaceholder",
-    "NGramOverlapExampleSelector",
-    "PipelinePromptTemplate",
-    "Prompt",
-    "PromptTemplate",
-    "SemanticSimilarityExampleSelector",
-    "StringPromptTemplate",
-    "SystemMessagePromptTemplate",
-    "load_prompt",
-]

langchain/prompts/base.py

@@ -1,21 +0,0 @@
-from langchain_core.prompt_values import StringPromptValue
-from langchain_core.prompts import (
-    BasePromptTemplate,
-    StringPromptTemplate,
-    check_valid_template,
-    get_template_variables,
-    jinja2_formatter,
-    validate_jinja2,
-)
-from langchain_core.prompts.string import _get_jinja2_variables_from_template
-
-__all__ = [
-    "BasePromptTemplate",
-    "StringPromptTemplate",
-    "StringPromptValue",
-    "_get_jinja2_variables_from_template",
-    "check_valid_template",
-    "get_template_variables",
-    "jinja2_formatter",
-    "validate_jinja2",
-]