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

langchain/retrievers/chatgpt_plugin_retriever.py

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

langchain/retrievers/cohere_rag_retriever.py

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

langchain/retrievers/contextual_compression.py

@@ -1,81 +0,0 @@
-from typing import Any
-
-from langchain_core.callbacks import (
-    AsyncCallbackManagerForRetrieverRun,
-    CallbackManagerForRetrieverRun,
-)
-from langchain_core.documents import BaseDocumentCompressor, Document
-from langchain_core.retrievers import BaseRetriever, RetrieverLike
-from pydantic import ConfigDict
-
-
-class ContextualCompressionRetriever(BaseRetriever):
-    """Retriever that wraps a base retriever and compresses the results."""
-
-    base_compressor: BaseDocumentCompressor
-    """Compressor for compressing retrieved documents."""
-
-    base_retriever: RetrieverLike
-    """Base Retriever to use for getting relevant documents."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def _get_relevant_documents(
-        self,
-        query: str,
-        *,
-        run_manager: CallbackManagerForRetrieverRun,
-        **kwargs: Any,
-    ) -> list[Document]:
-        """Get documents relevant for a query.
-
-        Args:
-            query: string to find relevant documents for
-
-        Returns:
-            Sequence of relevant documents
-        """
-        docs = self.base_retriever.invoke(
-            query,
-            config={"callbacks": run_manager.get_child()},
-            **kwargs,
-        )
-        if docs:
-            compressed_docs = self.base_compressor.compress_documents(
-                docs,
-                query,
-                callbacks=run_manager.get_child(),
-            )
-            return list(compressed_docs)
-        return []
-
-    async def _aget_relevant_documents(
-        self,
-        query: str,
-        *,
-        run_manager: AsyncCallbackManagerForRetrieverRun,
-        **kwargs: Any,
-    ) -> list[Document]:
-        """Get documents relevant for a query.
-
-        Args:
-            query: string to find relevant documents for
-
-        Returns:
-            List of relevant documents
-        """
-        docs = await self.base_retriever.ainvoke(
-            query,
-            config={"callbacks": run_manager.get_child()},
-            **kwargs,
-        )
-        if docs:
-            compressed_docs = await self.base_compressor.acompress_documents(
-                docs,
-                query,
-                callbacks=run_manager.get_child(),
-            )
-            return list(compressed_docs)
-        return []

langchain/retrievers/databerry.py

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

langchain/retrievers/docarray.py

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

langchain/retrievers/document_compressors/__init__.py

@@ -1,44 +0,0 @@
-import importlib
-from typing import Any
-
-from langchain.retrievers.document_compressors.base import DocumentCompressorPipeline
-from langchain.retrievers.document_compressors.chain_extract import (
-    LLMChainExtractor,
-)
-from langchain.retrievers.document_compressors.chain_filter import (
-    LLMChainFilter,
-)
-from langchain.retrievers.document_compressors.cohere_rerank import CohereRerank
-from langchain.retrievers.document_compressors.cross_encoder_rerank import (
-    CrossEncoderReranker,
-)
-from langchain.retrievers.document_compressors.embeddings_filter import (
-    EmbeddingsFilter,
-)
-from langchain.retrievers.document_compressors.listwise_rerank import (
-    LLMListwiseRerank,
-)
-
-_module_lookup = {
-    "FlashrankRerank": "langchain_community.document_compressors.flashrank_rerank",
-}
-
-
-def __getattr__(name: str) -> Any:
-    if name in _module_lookup:
-        module = importlib.import_module(_module_lookup[name])
-        return getattr(module, name)
-    msg = f"module {__name__} has no attribute {name}"
-    raise AttributeError(msg)
-
-
-__all__ = [
-    "CohereRerank",
-    "CrossEncoderReranker",
-    "DocumentCompressorPipeline",
-    "EmbeddingsFilter",
-    "FlashrankRerank",
-    "LLMChainExtractor",
-    "LLMChainFilter",
-    "LLMListwiseRerank",
-]

langchain/retrievers/document_compressors/base.py

@@ -1,82 +0,0 @@
-from collections.abc import Sequence
-from inspect import signature
-from typing import Optional, Union
-
-from langchain_core.callbacks import Callbacks
-from langchain_core.documents import (
-    BaseDocumentCompressor,
-    BaseDocumentTransformer,
-    Document,
-)
-from pydantic import ConfigDict
-
-
-class DocumentCompressorPipeline(BaseDocumentCompressor):
-    """Document compressor that uses a pipeline of Transformers."""
-
-    transformers: list[Union[BaseDocumentTransformer, BaseDocumentCompressor]]
-    """List of document filters that are chained together and run in sequence."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def compress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Transform a list of documents."""
-        for _transformer in self.transformers:
-            if isinstance(_transformer, BaseDocumentCompressor):
-                accepts_callbacks = (
-                    signature(_transformer.compress_documents).parameters.get(
-                        "callbacks",
-                    )
-                    is not None
-                )
-                if accepts_callbacks:
-                    documents = _transformer.compress_documents(
-                        documents,
-                        query,
-                        callbacks=callbacks,
-                    )
-                else:
-                    documents = _transformer.compress_documents(documents, query)
-            elif isinstance(_transformer, BaseDocumentTransformer):
-                documents = _transformer.transform_documents(documents)
-            else:
-                msg = f"Got unexpected transformer type: {_transformer}"
-                raise ValueError(msg)  # noqa: TRY004
-        return documents
-
-    async def acompress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Compress retrieved documents given the query context."""
-        for _transformer in self.transformers:
-            if isinstance(_transformer, BaseDocumentCompressor):
-                accepts_callbacks = (
-                    signature(_transformer.acompress_documents).parameters.get(
-                        "callbacks",
-                    )
-                    is not None
-                )
-                if accepts_callbacks:
-                    documents = await _transformer.acompress_documents(
-                        documents,
-                        query,
-                        callbacks=callbacks,
-                    )
-                else:
-                    documents = await _transformer.acompress_documents(documents, query)
-            elif isinstance(_transformer, BaseDocumentTransformer):
-                documents = await _transformer.atransform_documents(documents)
-            else:
-                msg = f"Got unexpected transformer type: {_transformer}"
-                raise ValueError(msg)  # noqa: TRY004
-        return documents

langchain/retrievers/document_compressors/chain_extract.py

@@ -1,123 +0,0 @@
-"""DocumentFilter that uses an LLM chain to extract the relevant parts of documents."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import Any, Callable, Optional, cast
-
-from langchain_core.callbacks import Callbacks
-from langchain_core.documents import BaseDocumentCompressor, Document
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import BaseOutputParser, StrOutputParser
-from langchain_core.prompts import PromptTemplate
-from langchain_core.runnables import Runnable
-from pydantic import ConfigDict
-from typing_extensions import override
-
-from langchain.chains.llm import LLMChain
-from langchain.retrievers.document_compressors.chain_extract_prompt import (
-    prompt_template,
-)
-
-
-def default_get_input(query: str, doc: Document) -> dict[str, Any]:
-    """Return the compression chain input."""
-    return {"question": query, "context": doc.page_content}
-
-
-class NoOutputParser(BaseOutputParser[str]):
-    """Parse outputs that could return a null string of some sort."""
-
-    no_output_str: str = "NO_OUTPUT"
-
-    @override
-    def parse(self, text: str) -> str:
-        cleaned_text = text.strip()
-        if cleaned_text == self.no_output_str:
-            return ""
-        return cleaned_text
-
-
-def _get_default_chain_prompt() -> PromptTemplate:
-    output_parser = NoOutputParser()
-    template = prompt_template.format(no_output_str=output_parser.no_output_str)
-    return PromptTemplate(
-        template=template,
-        input_variables=["question", "context"],
-        output_parser=output_parser,
-    )
-
-
-class LLMChainExtractor(BaseDocumentCompressor):
-    """Document compressor that uses an LLM chain to extract
-    the relevant parts of documents."""
-
-    llm_chain: Runnable
-    """LLM wrapper to use for compressing documents."""
-
-    get_input: Callable[[str, Document], dict] = default_get_input
-    """Callable for constructing the chain input from the query and a Document."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def compress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Compress page content of raw documents."""
-        compressed_docs = []
-        for doc in documents:
-            _input = self.get_input(query, doc)
-            output_ = self.llm_chain.invoke(_input, config={"callbacks": callbacks})
-            if isinstance(self.llm_chain, LLMChain):
-                output = output_[self.llm_chain.output_key]
-                if self.llm_chain.prompt.output_parser is not None:
-                    output = self.llm_chain.prompt.output_parser.parse(output)
-            else:
-                output = output_
-            if len(output) == 0:
-                continue
-            compressed_docs.append(
-                Document(page_content=cast("str", output), metadata=doc.metadata),
-            )
-        return compressed_docs
-
-    async def acompress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Compress page content of raw documents asynchronously."""
-        inputs = [self.get_input(query, doc) for doc in documents]
-        outputs = await self.llm_chain.abatch(inputs, {"callbacks": callbacks})
-        compressed_docs = []
-        for i, doc in enumerate(documents):
-            if len(outputs[i]) == 0:
-                continue
-            compressed_docs.append(
-                Document(page_content=outputs[i], metadata=doc.metadata),
-            )
-        return compressed_docs
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        prompt: Optional[PromptTemplate] = None,
-        get_input: Optional[Callable[[str, Document], str]] = None,
-        llm_chain_kwargs: Optional[dict] = None,  # noqa: ARG003
-    ) -> LLMChainExtractor:
-        """Initialize from LLM."""
-        _prompt = prompt if prompt is not None else _get_default_chain_prompt()
-        _get_input = get_input if get_input is not None else default_get_input
-        if _prompt.output_parser is not None:
-            parser = _prompt.output_parser
-        else:
-            parser = StrOutputParser()
-        llm_chain = _prompt | llm | parser
-        return cls(llm_chain=llm_chain, get_input=_get_input)  # type: ignore[arg-type]

langchain/retrievers/document_compressors/chain_extract_prompt.py

@@ -1,10 +0,0 @@
-prompt_template = """Given the following question and context, extract any part of the context *AS IS* that is relevant to answer the question. If none of the context is relevant return {no_output_str}.
-
-Remember, *DO NOT* edit the extracted parts of the context.
-
-> Question: {{question}}
-> Context:
->>>
-{{context}}
->>>
-Extracted relevant parts:"""  # noqa: E501

langchain/retrievers/document_compressors/chain_filter.py

@@ -1,133 +0,0 @@
-"""Filter that uses an LLM to drop documents that aren't relevant to the query."""
-
-from collections.abc import Sequence
-from typing import Any, Callable, Optional
-
-from langchain_core.callbacks import Callbacks
-from langchain_core.documents import BaseDocumentCompressor, Document
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.prompts import BasePromptTemplate, PromptTemplate
-from langchain_core.runnables import Runnable
-from langchain_core.runnables.config import RunnableConfig
-from pydantic import ConfigDict
-
-from langchain.chains import LLMChain
-from langchain.output_parsers.boolean import BooleanOutputParser
-from langchain.retrievers.document_compressors.chain_filter_prompt import (
-    prompt_template,
-)
-
-
-def _get_default_chain_prompt() -> PromptTemplate:
-    return PromptTemplate(
-        template=prompt_template,
-        input_variables=["question", "context"],
-        output_parser=BooleanOutputParser(),
-    )
-
-
-def default_get_input(query: str, doc: Document) -> dict[str, Any]:
-    """Return the compression chain input."""
-    return {"question": query, "context": doc.page_content}
-
-
-class LLMChainFilter(BaseDocumentCompressor):
-    """Filter that drops documents that aren't relevant to the query."""
-
-    llm_chain: Runnable
-    """LLM wrapper to use for filtering documents.
-    The chain prompt is expected to have a BooleanOutputParser."""
-
-    get_input: Callable[[str, Document], dict] = default_get_input
-    """Callable for constructing the chain input from the query and a Document."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def compress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Filter down documents based on their relevance to the query."""
-        filtered_docs = []
-
-        config = RunnableConfig(callbacks=callbacks)
-        outputs = zip(
-            self.llm_chain.batch(
-                [self.get_input(query, doc) for doc in documents],
-                config=config,
-            ),
-            documents,
-        )
-
-        for output_, doc in outputs:
-            include_doc = None
-            if isinstance(self.llm_chain, LLMChain):
-                output = output_[self.llm_chain.output_key]
-                if self.llm_chain.prompt.output_parser is not None:
-                    include_doc = self.llm_chain.prompt.output_parser.parse(output)
-            elif isinstance(output_, bool):
-                include_doc = output_
-            if include_doc:
-                filtered_docs.append(doc)
-
-        return filtered_docs
-
-    async def acompress_documents(
-        self,
-        documents: Sequence[Document],
-        query: str,
-        callbacks: Optional[Callbacks] = None,
-    ) -> Sequence[Document]:
-        """Filter down documents based on their relevance to the query."""
-        filtered_docs = []
-
-        config = RunnableConfig(callbacks=callbacks)
-        outputs = zip(
-            await self.llm_chain.abatch(
-                [self.get_input(query, doc) for doc in documents],
-                config=config,
-            ),
-            documents,
-        )
-        for output_, doc in outputs:
-            include_doc = None
-            if isinstance(self.llm_chain, LLMChain):
-                output = output_[self.llm_chain.output_key]
-                if self.llm_chain.prompt.output_parser is not None:
-                    include_doc = self.llm_chain.prompt.output_parser.parse(output)
-            elif isinstance(output_, bool):
-                include_doc = output_
-            if include_doc:
-                filtered_docs.append(doc)
-
-        return filtered_docs
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        prompt: Optional[BasePromptTemplate] = None,
-        **kwargs: Any,
-    ) -> "LLMChainFilter":
-        """Create a LLMChainFilter from a language model.
-
-        Args:
-            llm: The language model to use for filtering.
-            prompt: The prompt to use for the filter.
-            kwargs: Additional arguments to pass to the constructor.
-
-        Returns:
-            A LLMChainFilter that uses the given language model.
-        """
-        _prompt = prompt if prompt is not None else _get_default_chain_prompt()
-        if _prompt.output_parser is not None:
-            parser = _prompt.output_parser
-        else:
-            parser = StrOutputParser()
-        llm_chain = _prompt | llm | parser
-        return cls(llm_chain=llm_chain, **kwargs)

langchain/retrievers/document_compressors/chain_filter_prompt.py

@@ -1,8 +0,0 @@
-prompt_template = """Given the following question and context, return YES if the context is relevant to the question and NO if it isn't.
-
-> Question: {question}
-> Context:
->>>
-{context}
->>>
-> Relevant (YES / NO):"""  # noqa: E501