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

langchain/chains/openai_functions/tagging.py

@@ -1,174 +0,0 @@
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers.openai_functions import (
-    JsonOutputFunctionsParser,
-    PydanticOutputFunctionsParser,
-)
-from langchain_core.prompts import ChatPromptTemplate
-
-from langchain.chains.base import Chain
-from langchain.chains.llm import LLMChain
-from langchain.chains.openai_functions.utils import _convert_schema, get_llm_kwargs
-
-
-def _get_tagging_function(schema: dict) -> dict:
-    return {
-        "name": "information_extraction",
-        "description": "Extracts the relevant information from the passage.",
-        "parameters": _convert_schema(schema),
-    }
-
-
-_TAGGING_TEMPLATE = """Extract the desired information from the following passage.
-
-Only extract the properties mentioned in the 'information_extraction' function.
-
-Passage:
-{input}
-"""
-
-
-@deprecated(
-    since="0.2.13",
-    message=(
-        "LangChain has introduced a method called `with_structured_output` that "
-        "is available on ChatModels capable of tool calling. "
-        "See API reference for this function for replacement: "
-        "<https://api.python.langchain.com/en/latest/chains/langchain.chains.openai_functions.tagging.create_tagging_chain.html> "  # noqa: E501
-        "You can read more about `with_structured_output` here: "
-        "<https://python.langchain.com/docs/how_to/structured_output/>. "
-        "If you notice other issues, please provide "
-        "feedback here: "
-        "<https://github.com/langchain-ai/langchain/discussions/18154>"
-    ),
-    removal="1.0",
-)
-def create_tagging_chain(
-    schema: dict,
-    llm: BaseLanguageModel,
-    prompt: Optional[ChatPromptTemplate] = None,
-    **kwargs: Any,
-) -> Chain:
-    """Create a chain that extracts information from a passage
-     based on a schema.
-
-     This function is deprecated. Please use `with_structured_output` instead.
-     See example usage below:
-
-        .. code-block:: python
-
-            from typing_extensions import Annotated, TypedDict
-            from langchain_anthropic import ChatAnthropic
-
-            class Joke(TypedDict):
-                \"\"\"Tagged joke.\"\"\"
-
-                setup: Annotated[str, ..., "The setup of the joke"]
-                punchline: Annotated[str, ..., "The punchline of the joke"]
-
-            # Or any other chat model that supports tools.
-            # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support
-            # with_structured_output.
-            model = ChatAnthropic(model="claude-3-haiku-20240307", temperature=0)
-            structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke(
-                "Why did the cat cross the road? To get to the other "
-                "side... and then lay down in the middle of it!"
-            )
-    Read more here: https://python.langchain.com/docs/how_to/structured_output/
-
-    Args:
-        schema: The schema of the entities to extract.
-        llm: The language model to use.
-
-    Returns:
-        Chain (LLMChain) that can be used to extract information from a passage.
-
-    """
-    function = _get_tagging_function(schema)
-    prompt = prompt or ChatPromptTemplate.from_template(_TAGGING_TEMPLATE)
-    output_parser = JsonOutputFunctionsParser()
-    llm_kwargs = get_llm_kwargs(function)
-    return LLMChain(
-        llm=llm,
-        prompt=prompt,
-        llm_kwargs=llm_kwargs,
-        output_parser=output_parser,
-        **kwargs,
-    )
-
-
-@deprecated(
-    since="0.2.13",
-    message=(
-        "LangChain has introduced a method called `with_structured_output` that "
-        "is available on ChatModels capable of tool calling. "
-        "See API reference for this function for replacement: "
-        "<https://api.python.langchain.com/en/latest/chains/langchain.chains.openai_functions.tagging.create_tagging_chain_pydantic.html> "  # noqa: E501
-        "You can read more about `with_structured_output` here: "
-        "<https://python.langchain.com/docs/how_to/structured_output/>. "
-        "If you notice other issues, please provide "
-        "feedback here: "
-        "<https://github.com/langchain-ai/langchain/discussions/18154>"
-    ),
-    removal="1.0",
-)
-def create_tagging_chain_pydantic(
-    pydantic_schema: Any,
-    llm: BaseLanguageModel,
-    prompt: Optional[ChatPromptTemplate] = None,
-    **kwargs: Any,
-) -> Chain:
-    """Create a chain that extracts information from a passage
-     based on a pydantic schema.
-
-     This function is deprecated. Please use `with_structured_output` instead.
-     See example usage below:
-
-     .. code-block:: python
-
-            from pydantic import BaseModel, Field
-            from langchain_anthropic import ChatAnthropic
-
-            class Joke(BaseModel):
-                setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke")
-
-            # Or any other chat model that supports tools.
-            # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support
-            # with_structured_output.
-            model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
-            structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke(
-                "Why did the cat cross the road? To get to the other "
-                "side... and then lay down in the middle of it!"
-            )
-    Read more here: https://python.langchain.com/docs/how_to/structured_output/
-
-    Args:
-        pydantic_schema: The pydantic schema of the entities to extract.
-        llm: The language model to use.
-
-    Returns:
-        Chain (LLMChain) that can be used to extract information from a passage.
-
-    """
-    if hasattr(pydantic_schema, "model_json_schema"):
-        openai_schema = pydantic_schema.model_json_schema()
-    else:
-        openai_schema = pydantic_schema.schema()
-    function = _get_tagging_function(openai_schema)
-    prompt = prompt or ChatPromptTemplate.from_template(_TAGGING_TEMPLATE)
-    output_parser = PydanticOutputFunctionsParser(pydantic_schema=pydantic_schema)
-    llm_kwargs = get_llm_kwargs(function)
-    return LLMChain(
-        llm=llm,
-        prompt=prompt,
-        llm_kwargs=llm_kwargs,
-        output_parser=output_parser,
-        **kwargs,
-    )

langchain/chains/openai_functions/utils.py

@@ -1,40 +0,0 @@
-from typing import Any
-
-
-def _resolve_schema_references(schema: Any, definitions: dict[str, Any]) -> Any:
-    """
-    Resolve the $ref keys in a JSON schema object using the provided definitions.
-    """
-    if isinstance(schema, list):
-        for i, item in enumerate(schema):
-            schema[i] = _resolve_schema_references(item, definitions)
-    elif isinstance(schema, dict):
-        if "$ref" in schema:
-            ref_key = schema.pop("$ref").split("/")[-1]
-            ref = definitions.get(ref_key, {})
-            schema.update(ref)
-        else:
-            for key, value in schema.items():
-                schema[key] = _resolve_schema_references(value, definitions)
-    return schema
-
-
-def _convert_schema(schema: dict) -> dict:
-    props = {k: {"title": k, **v} for k, v in schema["properties"].items()}
-    return {
-        "type": "object",
-        "properties": props,
-        "required": schema.get("required", []),
-    }
-
-
-def get_llm_kwargs(function: dict) -> dict:
-    """Return the kwargs for the LLMChain constructor.
-
-    Args:
-        function: The function to use.
-
-    Returns:
-        The kwargs for the LLMChain constructor.
-    """
-    return {"functions": [function], "function_call": {"name": function["name"]}}

langchain/chains/openai_tools/__init__.py

@@ -1,3 +0,0 @@
-from langchain.chains.openai_tools.extraction import create_extraction_chain_pydantic
-
-__all__ = ["create_extraction_chain_pydantic"]

langchain/chains/openai_tools/extraction.py

@@ -1,79 +0,0 @@
-from typing import Union
-
-from langchain_core._api import deprecated
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers.openai_tools import PydanticToolsParser
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import Runnable
-from langchain_core.utils.function_calling import convert_pydantic_to_openai_function
-from pydantic import BaseModel
-
-_EXTRACTION_TEMPLATE = """Extract and save the relevant entities mentioned \
-in the following passage together with their properties.
-
-If a property is not present and is not required in the function parameters, do not include it in the output."""  # noqa: E501
-
-
-@deprecated(
-    since="0.1.14",
-    message=(
-        "LangChain has introduced a method called `with_structured_output` that"
-        "is available on ChatModels capable of tool calling."
-        "You can read more about the method here: "
-        "<https://python.langchain.com/docs/modules/model_io/chat/structured_output/>. "
-        "Please follow our extraction use case documentation for more guidelines"
-        "on how to do information extraction with LLMs."
-        "<https://python.langchain.com/docs/use_cases/extraction/>. "
-        "with_structured_output does not currently support a list of pydantic schemas. "
-        "If this is a blocker or if you notice other issues, please provide "
-        "feedback here:"
-        "<https://github.com/langchain-ai/langchain/discussions/18154>"
-    ),
-    removal="1.0",
-    alternative=(
-        """
-            from pydantic import BaseModel, Field
-            from langchain_anthropic import ChatAnthropic
-
-            class Joke(BaseModel):
-                setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke")
-
-            # Or any other chat model that supports tools.
-            # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support
-            # with_structured_output.
-            model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
-            structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats.
-                Make sure to call the Joke function.")
-            """
-    ),
-)
-def create_extraction_chain_pydantic(
-    pydantic_schemas: Union[list[type[BaseModel]], type[BaseModel]],
-    llm: BaseLanguageModel,
-    system_message: str = _EXTRACTION_TEMPLATE,
-) -> Runnable:
-    """Creates a chain that extracts information from a passage.
-
-    Args:
-        pydantic_schemas: The schema of the entities to extract.
-        llm: The language model to use.
-        system_message: The system message to use for extraction.
-
-    Returns:
-        A runnable that extracts information from a passage.
-    """
-    if not isinstance(pydantic_schemas, list):
-        pydantic_schemas = [pydantic_schemas]
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            ("system", system_message),
-            ("user", "{input}"),
-        ],
-    )
-    functions = [convert_pydantic_to_openai_function(p) for p in pydantic_schemas]
-    tools = [{"type": "function", "function": d} for d in functions]
-    model = llm.bind(tools=tools)
-    return prompt | model | PydanticToolsParser(tools=pydantic_schemas)

langchain/chains/prompt_selector.py

@@ -1,65 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Callable
-
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.language_models.chat_models import BaseChatModel
-from langchain_core.language_models.llms import BaseLLM
-from langchain_core.prompts import BasePromptTemplate
-from pydantic import BaseModel, Field
-
-
-class BasePromptSelector(BaseModel, ABC):
-    """Base class for prompt selectors."""
-
-    @abstractmethod
-    def get_prompt(self, llm: BaseLanguageModel) -> BasePromptTemplate:
-        """Get default prompt for a language model."""
-
-
-class ConditionalPromptSelector(BasePromptSelector):
-    """Prompt collection that goes through conditionals."""
-
-    default_prompt: BasePromptTemplate
-    """Default prompt to use if no conditionals match."""
-    conditionals: list[
-        tuple[Callable[[BaseLanguageModel], bool], BasePromptTemplate]
-    ] = Field(default_factory=list)
-    """List of conditionals and prompts to use if the conditionals match."""
-
-    def get_prompt(self, llm: BaseLanguageModel) -> BasePromptTemplate:
-        """Get default prompt for a language model.
-
-        Args:
-            llm: Language model to get prompt for.
-
-        Returns:
-            Prompt to use for the language model.
-        """
-        for condition, prompt in self.conditionals:
-            if condition(llm):
-                return prompt
-        return self.default_prompt
-
-
-def is_llm(llm: BaseLanguageModel) -> bool:
-    """Check if the language model is a LLM.
-
-    Args:
-        llm: Language model to check.
-
-    Returns:
-        True if the language model is a BaseLLM model, False otherwise.
-    """
-    return isinstance(llm, BaseLLM)
-
-
-def is_chat_model(llm: BaseLanguageModel) -> bool:
-    """Check if the language model is a chat model.
-
-    Args:
-        llm: Language model to check.
-
-    Returns:
-        True if the language model is a BaseChatModel model, False otherwise.
-    """
-    return isinstance(llm, BaseChatModel)

langchain/chains/qa_generation/base.py

@@ -1,128 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.callbacks import CallbackManagerForChainRun
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts import BasePromptTemplate
-from langchain_text_splitters import RecursiveCharacterTextSplitter, TextSplitter
-from pydantic import Field
-from typing_extensions import override
-
-from langchain.chains.base import Chain
-from langchain.chains.llm import LLMChain
-from langchain.chains.qa_generation.prompt import PROMPT_SELECTOR
-
-
-@deprecated(
-    since="0.2.7",
-    alternative=(
-        "example in API reference with more detail: "
-        "https://api.python.langchain.com/en/latest/chains/langchain.chains.qa_generation.base.QAGenerationChain.html"
-    ),
-    removal="1.0",
-)
-class QAGenerationChain(Chain):
-    """Base class for question-answer generation chains.
-
-    This class is deprecated. See below for an alternative implementation.
-
-    Advantages of this implementation include:
-
-    - Supports async and streaming;
-    - Surfaces prompt and text splitter for easier customization;
-    - Use of JsonOutputParser supports JSONPatch operations in streaming mode,
-      as well as robustness to markdown.
-
-        .. code-block:: python
-
-            from langchain.chains.qa_generation.prompt import CHAT_PROMPT as prompt
-            # Note: import PROMPT if using a legacy non-chat model.
-            from langchain_core.output_parsers import JsonOutputParser
-            from langchain_core.runnables import (
-                RunnableLambda,
-                RunnableParallel,
-                RunnablePassthrough,
-            )
-            from langchain_core.runnables.base import RunnableEach
-            from langchain_openai import ChatOpenAI
-            from langchain_text_splitters import RecursiveCharacterTextSplitter
-
-            llm = ChatOpenAI()
-            text_splitter = RecursiveCharacterTextSplitter(chunk_overlap=500)
-            split_text = RunnableLambda(
-                lambda x: text_splitter.create_documents([x])
-            )
-
-            chain = RunnableParallel(
-                text=RunnablePassthrough(),
-                questions=(
-                    split_text | RunnableEach(bound=prompt | llm | JsonOutputParser())
-                )
-            )
-
-    """
-
-    llm_chain: LLMChain
-    """LLM Chain that generates responses from user input and context."""
-    text_splitter: TextSplitter = Field(
-        default=RecursiveCharacterTextSplitter(chunk_overlap=500),
-    )
-    """Text splitter that splits the input into chunks."""
-    input_key: str = "text"
-    """Key of the input to the chain."""
-    output_key: str = "questions"
-    """Key of the output of the chain."""
-    k: Optional[int] = None
-    """Number of questions to generate."""
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        prompt: Optional[BasePromptTemplate] = None,
-        **kwargs: Any,
-    ) -> QAGenerationChain:
-        """
-        Create a QAGenerationChain from a language model.
-
-        Args:
-            llm: a language model
-            prompt: a prompt template
-            **kwargs: additional arguments
-
-        Returns:
-            a QAGenerationChain class
-        """
-        _prompt = prompt or PROMPT_SELECTOR.get_prompt(llm)
-        chain = LLMChain(llm=llm, prompt=_prompt)
-        return cls(llm_chain=chain, **kwargs)
-
-    @property
-    def _chain_type(self) -> str:
-        raise NotImplementedError
-
-    @property
-    @override
-    def input_keys(self) -> list[str]:
-        return [self.input_key]
-
-    @property
-    @override
-    def output_keys(self) -> list[str]:
-        return [self.output_key]
-
-    def _call(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, list]:
-        docs = self.text_splitter.create_documents([inputs[self.input_key]])
-        results = self.llm_chain.generate(
-            [{"text": d.page_content} for d in docs],
-            run_manager=run_manager,
-        )
-        qa = [json.loads(res[0].text) for res in results.generations]
-        return {self.output_key: qa}

langchain/chains/qa_generation/prompt.py

@@ -1,50 +0,0 @@
-from langchain_core.prompts.chat import (
-    ChatPromptTemplate,
-    HumanMessagePromptTemplate,
-    SystemMessagePromptTemplate,
-)
-from langchain_core.prompts.prompt import PromptTemplate
-
-from langchain.chains.prompt_selector import ConditionalPromptSelector, is_chat_model
-
-templ1 = """You are a smart assistant designed to help high school teachers come up with reading comprehension questions.
-Given a piece of text, you must come up with a question and answer pair that can be used to test a student's reading comprehension abilities.
-When coming up with this question/answer pair, you must respond in the following format:
-```
-{{
-    "question": "$YOUR_QUESTION_HERE",
-    "answer": "$THE_ANSWER_HERE"
-}}
-```
-
-Everything between the ``` must be valid json.
-"""  # noqa: E501
-templ2 = """Please come up with a question/answer pair, in the specified JSON format, for the following text:
-----------------
-{text}"""  # noqa: E501
-CHAT_PROMPT = ChatPromptTemplate.from_messages(
-    [
-        SystemMessagePromptTemplate.from_template(templ1),
-        HumanMessagePromptTemplate.from_template(templ2),
-    ]
-)
-templ = """You are a smart assistant designed to help high school teachers come up with reading comprehension questions.
-Given a piece of text, you must come up with a question and answer pair that can be used to test a student's reading comprehension abilities.
-When coming up with this question/answer pair, you must respond in the following format:
-```
-{{
-    "question": "$YOUR_QUESTION_HERE",
-    "answer": "$THE_ANSWER_HERE"
-}}
-```
-
-Everything between the ``` must be valid json.
-
-Please come up with a question/answer pair, in the specified JSON format, for the following text:
-----------------
-{text}"""  # noqa: E501
-PROMPT = PromptTemplate.from_template(templ)
-
-PROMPT_SELECTOR = ConditionalPromptSelector(
-    default_prompt=PROMPT, conditionals=[(is_chat_model, CHAT_PROMPT)]
-)

langchain/chains/qa_with_sources/__init__.py

@@ -1,5 +0,0 @@
-"""Load question answering with sources chains."""
-
-from langchain.chains.qa_with_sources.loading import load_qa_with_sources_chain
-
-__all__ = ["load_qa_with_sources_chain"]