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

langchain/chains/hyde/base.py

@@ -1,124 +0,0 @@
-"""Hypothetical Document Embeddings.
-
-https://arxiv.org/abs/2212.10496
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Optional
-
-from langchain_core.callbacks import CallbackManagerForChainRun
-from langchain_core.embeddings import Embeddings
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.runnables import Runnable
-from pydantic import ConfigDict
-
-from langchain.chains.base import Chain
-from langchain.chains.hyde.prompts import PROMPT_MAP
-from langchain.chains.llm import LLMChain
-
-logger = logging.getLogger(__name__)
-
-
-class HypotheticalDocumentEmbedder(Chain, Embeddings):
-    """Generate hypothetical document for query, and then embed that.
-
-    Based on https://arxiv.org/abs/2212.10496
-    """
-
-    base_embeddings: Embeddings
-    llm_chain: Runnable
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        extra="forbid",
-    )
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Input keys for Hyde's LLM chain."""
-        return self.llm_chain.input_schema.model_json_schema()["required"]
-
-    @property
-    def output_keys(self) -> list[str]:
-        """Output keys for Hyde's LLM chain."""
-        if isinstance(self.llm_chain, LLMChain):
-            return self.llm_chain.output_keys
-        return ["text"]
-
-    def embed_documents(self, texts: list[str]) -> list[list[float]]:
-        """Call the base embeddings."""
-        return self.base_embeddings.embed_documents(texts)
-
-    def combine_embeddings(self, embeddings: list[list[float]]) -> list[float]:
-        """Combine embeddings into final embeddings."""
-        try:
-            import numpy as np
-
-            return list(np.array(embeddings).mean(axis=0))
-        except ImportError:
-            logger.warning(
-                "NumPy not found in the current Python environment. "
-                "HypotheticalDocumentEmbedder will use a pure Python implementation "
-                "for internal calculations, which may significantly impact "
-                "performance, especially for large datasets. For optimal speed and "
-                "efficiency, consider installing NumPy: pip install numpy",
-            )
-            if not embeddings:
-                return []
-            num_vectors = len(embeddings)
-            return [sum(dim_values) / num_vectors for dim_values in zip(*embeddings)]
-
-    def embed_query(self, text: str) -> list[float]:
-        """Generate a hypothetical document and embedded it."""
-        var_name = self.input_keys[0]
-        result = self.llm_chain.invoke({var_name: text})
-        if isinstance(self.llm_chain, LLMChain):
-            documents = [result[self.output_keys[0]]]
-        else:
-            documents = [result]
-        embeddings = self.embed_documents(documents)
-        return self.combine_embeddings(embeddings)
-
-    def _call(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, str]:
-        """Call the internal llm chain."""
-        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        return self.llm_chain.invoke(
-            inputs,
-            config={"callbacks": _run_manager.get_child()},
-        )
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        base_embeddings: Embeddings,
-        prompt_key: Optional[str] = None,
-        custom_prompt: Optional[BasePromptTemplate] = None,
-        **kwargs: Any,
-    ) -> HypotheticalDocumentEmbedder:
-        """Load and use LLMChain with either a specific prompt key or custom prompt."""
-        if custom_prompt is not None:
-            prompt = custom_prompt
-        elif prompt_key is not None and prompt_key in PROMPT_MAP:
-            prompt = PROMPT_MAP[prompt_key]
-        else:
-            msg = (
-                f"Must specify prompt_key if custom_prompt not provided. Should be one "
-                f"of {list(PROMPT_MAP.keys())}."
-            )
-            raise ValueError(msg)
-
-        llm_chain = prompt | llm | StrOutputParser()
-        return cls(base_embeddings=base_embeddings, llm_chain=llm_chain, **kwargs)
-
-    @property
-    def _chain_type(self) -> str:
-        return "hyde_chain"

langchain/chains/hyde/prompts.py

@@ -1,46 +0,0 @@
-from langchain_core.prompts.prompt import PromptTemplate
-
-web_search_template = """Please write a passage to answer the question
-Question: {QUESTION}
-Passage:"""
-web_search = PromptTemplate(template=web_search_template, input_variables=["QUESTION"])
-sci_fact_template = """Please write a scientific paper passage to support/refute the claim
-Claim: {Claim}
-Passage:"""  # noqa: E501
-sci_fact = PromptTemplate(template=sci_fact_template, input_variables=["Claim"])
-arguana_template = """Please write a counter argument for the passage
-Passage: {PASSAGE}
-Counter Argument:"""
-arguana = PromptTemplate(template=arguana_template, input_variables=["PASSAGE"])
-trec_covid_template = """Please write a scientific paper passage to answer the question
-Question: {QUESTION}
-Passage:"""
-trec_covid = PromptTemplate(template=trec_covid_template, input_variables=["QUESTION"])
-fiqa_template = """Please write a financial article passage to answer the question
-Question: {QUESTION}
-Passage:"""
-fiqa = PromptTemplate(template=fiqa_template, input_variables=["QUESTION"])
-dbpedia_entity_template = """Please write a passage to answer the question.
-Question: {QUESTION}
-Passage:"""
-dbpedia_entity = PromptTemplate(
-    template=dbpedia_entity_template, input_variables=["QUESTION"]
-)
-trec_news_template = """Please write a news passage about the topic.
-Topic: {TOPIC}
-Passage:"""
-trec_news = PromptTemplate(template=trec_news_template, input_variables=["TOPIC"])
-mr_tydi_template = """Please write a passage in Swahili/Korean/Japanese/Bengali to answer the question in detail.
-Question: {QUESTION}
-Passage:"""  # noqa: E501
-mr_tydi = PromptTemplate(template=mr_tydi_template, input_variables=["QUESTION"])
-PROMPT_MAP = {
-    "web_search": web_search,
-    "sci_fact": sci_fact,
-    "arguana": arguana,
-    "trec_covid": trec_covid,
-    "fiqa": fiqa,
-    "dbpedia_entity": dbpedia_entity,
-    "trec_news": trec_news,
-    "mr_tydi": mr_tydi,
-}

langchain/chains/llm.py

@@ -1,447 +0,0 @@
-"""Chain that just formats a prompt and calls an LLM."""
-
-from __future__ import annotations
-
-import warnings
-from collections.abc import Sequence
-from typing import Any, Optional, Union, cast
-
-from langchain_core._api import deprecated
-from langchain_core.callbacks import (
-    AsyncCallbackManager,
-    AsyncCallbackManagerForChainRun,
-    CallbackManager,
-    CallbackManagerForChainRun,
-    Callbacks,
-)
-from langchain_core.language_models import (
-    BaseLanguageModel,
-    LanguageModelInput,
-)
-from langchain_core.messages import BaseMessage
-from langchain_core.output_parsers import BaseLLMOutputParser, StrOutputParser
-from langchain_core.outputs import ChatGeneration, Generation, LLMResult
-from langchain_core.prompt_values import PromptValue
-from langchain_core.prompts import BasePromptTemplate, PromptTemplate
-from langchain_core.runnables import (
-    Runnable,
-    RunnableBinding,
-    RunnableBranch,
-    RunnableWithFallbacks,
-)
-from langchain_core.runnables.configurable import DynamicRunnable
-from langchain_core.utils.input import get_colored_text
-from pydantic import ConfigDict, Field
-from typing_extensions import override
-
-from langchain.chains.base import Chain
-
-
-@deprecated(
-    since="0.1.17",
-    alternative="RunnableSequence, e.g., `prompt | llm`",
-    removal="1.0",
-)
-class LLMChain(Chain):
-    """Chain to run queries against LLMs.
-
-    This class is deprecated. See below for an example implementation using
-    LangChain runnables:
-
-        .. code-block:: python
-
-            from langchain_core.output_parsers import StrOutputParser
-            from langchain_core.prompts import PromptTemplate
-            from langchain_openai import OpenAI
-
-            prompt_template = "Tell me a {adjective} joke"
-            prompt = PromptTemplate(
-                input_variables=["adjective"], template=prompt_template
-            )
-            llm = OpenAI()
-            chain = prompt | llm | StrOutputParser()
-
-            chain.invoke("your adjective here")
-
-    Example:
-        .. code-block:: python
-
-            from langchain.chains import LLMChain
-            from langchain_community.llms import OpenAI
-            from langchain_core.prompts import PromptTemplate
-            prompt_template = "Tell me a {adjective} joke"
-            prompt = PromptTemplate(
-                input_variables=["adjective"], template=prompt_template
-            )
-            llm = LLMChain(llm=OpenAI(), prompt=prompt)
-
-    """
-
-    @classmethod
-    @override
-    def is_lc_serializable(self) -> bool:
-        return True
-
-    prompt: BasePromptTemplate
-    """Prompt object to use."""
-    llm: Union[
-        Runnable[LanguageModelInput, str],
-        Runnable[LanguageModelInput, BaseMessage],
-    ]
-    """Language model to call."""
-    output_key: str = "text"  #: :meta private:
-    output_parser: BaseLLMOutputParser = Field(default_factory=StrOutputParser)
-    """Output parser to use.
-    Defaults to one that takes the most likely string but does not change it
-    otherwise."""
-    return_final_only: bool = True
-    """Whether to return only the final parsed result. Defaults to True.
-    If false, will return a bunch of extra information about the generation."""
-    llm_kwargs: dict = Field(default_factory=dict)
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        extra="forbid",
-    )
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Will be whatever keys the prompt expects.
-
-        :meta private:
-        """
-        return self.prompt.input_variables
-
-    @property
-    def output_keys(self) -> list[str]:
-        """Will always return text key.
-
-        :meta private:
-        """
-        if self.return_final_only:
-            return [self.output_key]
-        return [self.output_key, "full_generation"]
-
-    def _call(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, str]:
-        response = self.generate([inputs], run_manager=run_manager)
-        return self.create_outputs(response)[0]
-
-    def generate(
-        self,
-        input_list: list[dict[str, Any]],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> LLMResult:
-        """Generate LLM result from inputs."""
-        prompts, stop = self.prep_prompts(input_list, run_manager=run_manager)
-        callbacks = run_manager.get_child() if run_manager else None
-        if isinstance(self.llm, BaseLanguageModel):
-            return self.llm.generate_prompt(
-                prompts,
-                stop,
-                callbacks=callbacks,
-                **self.llm_kwargs,
-            )
-        results = self.llm.bind(stop=stop, **self.llm_kwargs).batch(
-            cast("list", prompts),
-            {"callbacks": callbacks},
-        )
-        generations: list[list[Generation]] = []
-        for res in results:
-            if isinstance(res, BaseMessage):
-                generations.append([ChatGeneration(message=res)])
-            else:
-                generations.append([Generation(text=res)])
-        return LLMResult(generations=generations)
-
-    async def agenerate(
-        self,
-        input_list: list[dict[str, Any]],
-        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> LLMResult:
-        """Generate LLM result from inputs."""
-        prompts, stop = await self.aprep_prompts(input_list, run_manager=run_manager)
-        callbacks = run_manager.get_child() if run_manager else None
-        if isinstance(self.llm, BaseLanguageModel):
-            return await self.llm.agenerate_prompt(
-                prompts,
-                stop,
-                callbacks=callbacks,
-                **self.llm_kwargs,
-            )
-        results = await self.llm.bind(stop=stop, **self.llm_kwargs).abatch(
-            cast("list", prompts),
-            {"callbacks": callbacks},
-        )
-        generations: list[list[Generation]] = []
-        for res in results:
-            if isinstance(res, BaseMessage):
-                generations.append([ChatGeneration(message=res)])
-            else:
-                generations.append([Generation(text=res)])
-        return LLMResult(generations=generations)
-
-    def prep_prompts(
-        self,
-        input_list: list[dict[str, Any]],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> tuple[list[PromptValue], Optional[list[str]]]:
-        """Prepare prompts from inputs."""
-        stop = None
-        if len(input_list) == 0:
-            return [], stop
-        if "stop" in input_list[0]:
-            stop = input_list[0]["stop"]
-        prompts = []
-        for inputs in input_list:
-            selected_inputs = {k: inputs[k] for k in self.prompt.input_variables}
-            prompt = self.prompt.format_prompt(**selected_inputs)
-            _colored_text = get_colored_text(prompt.to_string(), "green")
-            _text = "Prompt after formatting:\n" + _colored_text
-            if run_manager:
-                run_manager.on_text(_text, end="\n", verbose=self.verbose)
-            if "stop" in inputs and inputs["stop"] != stop:
-                msg = "If `stop` is present in any inputs, should be present in all."
-                raise ValueError(msg)
-            prompts.append(prompt)
-        return prompts, stop
-
-    async def aprep_prompts(
-        self,
-        input_list: list[dict[str, Any]],
-        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> tuple[list[PromptValue], Optional[list[str]]]:
-        """Prepare prompts from inputs."""
-        stop = None
-        if len(input_list) == 0:
-            return [], stop
-        if "stop" in input_list[0]:
-            stop = input_list[0]["stop"]
-        prompts = []
-        for inputs in input_list:
-            selected_inputs = {k: inputs[k] for k in self.prompt.input_variables}
-            prompt = self.prompt.format_prompt(**selected_inputs)
-            _colored_text = get_colored_text(prompt.to_string(), "green")
-            _text = "Prompt after formatting:\n" + _colored_text
-            if run_manager:
-                await run_manager.on_text(_text, end="\n", verbose=self.verbose)
-            if "stop" in inputs and inputs["stop"] != stop:
-                msg = "If `stop` is present in any inputs, should be present in all."
-                raise ValueError(msg)
-            prompts.append(prompt)
-        return prompts, stop
-
-    def apply(
-        self,
-        input_list: list[dict[str, Any]],
-        callbacks: Callbacks = None,
-    ) -> list[dict[str, str]]:
-        """Utilize the LLM generate method for speed gains."""
-        callback_manager = CallbackManager.configure(
-            callbacks,
-            self.callbacks,
-            self.verbose,
-        )
-        run_manager = callback_manager.on_chain_start(
-            None,
-            {"input_list": input_list},
-            name=self.get_name(),
-        )
-        try:
-            response = self.generate(input_list, run_manager=run_manager)
-        except BaseException as e:
-            run_manager.on_chain_error(e)
-            raise
-        outputs = self.create_outputs(response)
-        run_manager.on_chain_end({"outputs": outputs})
-        return outputs
-
-    async def aapply(
-        self,
-        input_list: list[dict[str, Any]],
-        callbacks: Callbacks = None,
-    ) -> list[dict[str, str]]:
-        """Utilize the LLM generate method for speed gains."""
-        callback_manager = AsyncCallbackManager.configure(
-            callbacks,
-            self.callbacks,
-            self.verbose,
-        )
-        run_manager = await callback_manager.on_chain_start(
-            None,
-            {"input_list": input_list},
-            name=self.get_name(),
-        )
-        try:
-            response = await self.agenerate(input_list, run_manager=run_manager)
-        except BaseException as e:
-            await run_manager.on_chain_error(e)
-            raise
-        outputs = self.create_outputs(response)
-        await run_manager.on_chain_end({"outputs": outputs})
-        return outputs
-
-    @property
-    def _run_output_key(self) -> str:
-        return self.output_key
-
-    def create_outputs(self, llm_result: LLMResult) -> list[dict[str, Any]]:
-        """Create outputs from response."""
-        result = [
-            # Get the text of the top generated string.
-            {
-                self.output_key: self.output_parser.parse_result(generation),
-                "full_generation": generation,
-            }
-            for generation in llm_result.generations
-        ]
-        if self.return_final_only:
-            result = [{self.output_key: r[self.output_key]} for r in result]
-        return result
-
-    async def _acall(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> dict[str, str]:
-        response = await self.agenerate([inputs], run_manager=run_manager)
-        return self.create_outputs(response)[0]
-
-    def predict(self, callbacks: Callbacks = None, **kwargs: Any) -> str:
-        """Format prompt with kwargs and pass to LLM.
-
-        Args:
-            callbacks: Callbacks to pass to LLMChain
-            **kwargs: Keys to pass to prompt template.
-
-        Returns:
-            Completion from LLM.
-
-        Example:
-            .. code-block:: python
-
-                completion = llm.predict(adjective="funny")
-
-        """
-        return self(kwargs, callbacks=callbacks)[self.output_key]
-
-    async def apredict(self, callbacks: Callbacks = None, **kwargs: Any) -> str:
-        """Format prompt with kwargs and pass to LLM.
-
-        Args:
-            callbacks: Callbacks to pass to LLMChain
-            **kwargs: Keys to pass to prompt template.
-
-        Returns:
-            Completion from LLM.
-
-        Example:
-            .. code-block:: python
-
-                completion = llm.predict(adjective="funny")
-
-        """
-        return (await self.acall(kwargs, callbacks=callbacks))[self.output_key]
-
-    def predict_and_parse(
-        self,
-        callbacks: Callbacks = None,
-        **kwargs: Any,
-    ) -> Union[str, list[str], dict[str, Any]]:
-        """Call predict and then parse the results."""
-        warnings.warn(
-            "The predict_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain.",
-            stacklevel=2,
-        )
-        result = self.predict(callbacks=callbacks, **kwargs)
-        if self.prompt.output_parser is not None:
-            return self.prompt.output_parser.parse(result)
-        return result
-
-    async def apredict_and_parse(
-        self,
-        callbacks: Callbacks = None,
-        **kwargs: Any,
-    ) -> Union[str, list[str], dict[str, str]]:
-        """Call apredict and then parse the results."""
-        warnings.warn(
-            "The apredict_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain.",
-            stacklevel=2,
-        )
-        result = await self.apredict(callbacks=callbacks, **kwargs)
-        if self.prompt.output_parser is not None:
-            return self.prompt.output_parser.parse(result)
-        return result
-
-    def apply_and_parse(
-        self,
-        input_list: list[dict[str, Any]],
-        callbacks: Callbacks = None,
-    ) -> Sequence[Union[str, list[str], dict[str, str]]]:
-        """Call apply and then parse the results."""
-        warnings.warn(
-            "The apply_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain.",
-            stacklevel=2,
-        )
-        result = self.apply(input_list, callbacks=callbacks)
-        return self._parse_generation(result)
-
-    def _parse_generation(
-        self,
-        generation: list[dict[str, str]],
-    ) -> Sequence[Union[str, list[str], dict[str, str]]]:
-        if self.prompt.output_parser is not None:
-            return [
-                self.prompt.output_parser.parse(res[self.output_key])
-                for res in generation
-            ]
-        return generation
-
-    async def aapply_and_parse(
-        self,
-        input_list: list[dict[str, Any]],
-        callbacks: Callbacks = None,
-    ) -> Sequence[Union[str, list[str], dict[str, str]]]:
-        """Call apply and then parse the results."""
-        warnings.warn(
-            "The aapply_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain.",
-            stacklevel=2,
-        )
-        result = await self.aapply(input_list, callbacks=callbacks)
-        return self._parse_generation(result)
-
-    @property
-    def _chain_type(self) -> str:
-        return "llm_chain"
-
-    @classmethod
-    def from_string(cls, llm: BaseLanguageModel, template: str) -> LLMChain:
-        """Create LLMChain from LLM and template."""
-        prompt_template = PromptTemplate.from_template(template)
-        return cls(llm=llm, prompt=prompt_template)
-
-    def _get_num_tokens(self, text: str) -> int:
-        return _get_language_model(self.llm).get_num_tokens(text)
-
-
-def _get_language_model(llm_like: Runnable) -> BaseLanguageModel:
-    if isinstance(llm_like, BaseLanguageModel):
-        return llm_like
-    if isinstance(llm_like, RunnableBinding):
-        return _get_language_model(llm_like.bound)
-    if isinstance(llm_like, RunnableWithFallbacks):
-        return _get_language_model(llm_like.runnable)
-    if isinstance(llm_like, (RunnableBranch, DynamicRunnable)):
-        return _get_language_model(llm_like.default)
-    msg = (
-        f"Unable to extract BaseLanguageModel from llm_like object of type "
-        f"{type(llm_like)}"
-    )
-    raise ValueError(msg)

langchain/chains/llm_bash/__init__.py

@@ -1,10 +0,0 @@
-def __getattr__(_: str = "") -> None:
-    """Raise an error on import since is deprecated."""
-    msg = (
-        "This module has been moved to langchain-experimental. "
-        "For more details: https://github.com/langchain-ai/langchain/discussions/11352."
-        "To access this code, install it with `pip install langchain-experimental`."
-        "`from langchain_experimental.llm_bash.base "
-        "import LLMBashChain`"
-    )
-    raise AttributeError(msg)

langchain/chains/llm_checker/__init__.py

@@ -1,4 +0,0 @@
-"""Chain that tries to verify assumptions before answering a question.
-
-Heavily borrowed from https://github.com/jagilley/fact-checker
-"""