
    Ng>                    D   d Z ddlmZ ddlZddlmZmZ ddlmZ ddl	m
Z
mZmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZmZmZmZ ddlmZ e
r
ddlmZmZmZ e Z!e"e         Z#ee!e#f         Z$eee#f         Z% G d ded          Z& G d dee!e#f         e          Z'dS )a  **Retriever** class returns Documents given a text **query**.

It is more general than a vector store. A retriever does not need to be able to
store documents, only to return (or retrieve) it. Vector stores can be used as
the backbone of a retriever, but there are other types of retrievers as well.

**Class hierarchy:**

.. code-block::

    BaseRetriever --> <name>Retriever  # Examples: ArxivRetriever, MergerRetriever

**Main helpers:**

.. code-block::

    RetrieverInput, RetrieverOutput, RetrieverLike, RetrieverOutputLike,
    Document, Serializable, Callbacks,
    CallbackManagerForRetrieverRun, AsyncCallbackManagerForRetrieverRun
    )annotationsN)ABCabstractmethod)	signature)TYPE_CHECKINGAnyOptional)
ConfigDict)	TypedDict)
deprecated)Document)RunnableRunnableConfigRunnableSerializableensure_config)run_in_executor)#AsyncCallbackManagerForRetrieverRunCallbackManagerForRetrieverRun	Callbacksc                  B    e Zd ZU dZded<   	 ded<   	 ded<   	 ded<   dS )	LangSmithRetrieverParamsz!LangSmith parameters for tracing.strls_retriever_nameOptional[str]ls_vector_store_providerls_embedding_providerls_embedding_modelN)__name__
__module____qualname____doc____annotations__     U/var/www/html/ai-engine/env/lib/python3.11/site-packages/langchain_core/retrievers.pyr   r   7   sQ         ++++++ ((((%%%%r$   r   F)totalc                  2    e Zd ZU dZ ed          ZdZded<   dZded<   dZ	d	ed
<   	 dZ
ded<   	 d- fdZd.dZ	 d/d0dZ	 d/d0dZed1d            Zd2d Z ed!d"d#$          ddddd%d3d*            Z ed!d+d#$          ddddd%d3d,            Z xZS )4BaseRetrievera	  Abstract base class for a Document retrieval system.

    A retrieval system is defined as something that can take string queries and return
    the most 'relevant' Documents from some source.

    Usage:

    A retriever follows the standard Runnable interface, and should be used
    via the standard Runnable methods of `invoke`, `ainvoke`, `batch`, `abatch`.

    Implementation:

    When implementing a custom retriever, the class should implement
    the `_get_relevant_documents` method to define the logic for retrieving documents.

    Optionally, an async native implementations can be provided by overriding the
    `_aget_relevant_documents` method.

    Example: A retriever that returns the first 5 documents from a list of documents

        .. code-block:: python

            from langchain_core import Document, BaseRetriever
            from typing import List

            class SimpleRetriever(BaseRetriever):
                docs: List[Document]
                k: int = 5

                def _get_relevant_documents(self, query: str) -> List[Document]:
                    """Return the first k documents from the list of documents"""
                    return self.docs[:self.k]

                async def _aget_relevant_documents(self, query: str) -> List[Document]:
                    """(Optional) async native implementation."""
                    return self.docs[:self.k]

    Example: A simple retriever based on a scikit-learn vectorizer

        .. code-block:: python

            from sklearn.metrics.pairwise import cosine_similarity

            class TFIDFRetriever(BaseRetriever, BaseModel):
                vectorizer: Any
                docs: List[Document]
                tfidf_array: Any
                k: int = 4

                class Config:
                    arbitrary_types_allowed = True

                def _get_relevant_documents(self, query: str) -> List[Document]:
                    # Ip -- (n_docs,x), Op -- (n_docs,n_Feats)
                    query_vec = self.vectorizer.transform([query])
                    # Op -- (n_docs,1) -- Cosine Sim with each doc
                    results = cosine_similarity(self.tfidf_array, query_vec).reshape((-1,))
                    return [self.docs[i] for i in results.argsort()[-self.k :][::-1]]
    T)arbitrary_types_allowedFbool_new_arg_supported_expects_other_argsNOptional[list[str]]tagsOptional[dict[str, Any]]metadatakwargsr   returnNonec                |    t                      j        d	i | | j        t          j        k    r;t	          j        dt          d           | j        }t          j        | _        || _        t          | d          rP| j	        t          j	        k    r;t	          j        dt          d           | j	        }t          j	        | _	        || _
        t          | j                  j        }|                    d          d u| _        t          t!          |                                          h dz
            dk    | _        d S )
NzgRetrievers must implement abstract `_get_relevant_documents` method instead of `get_relevant_documents`   )
stacklevelaget_relevant_documentsziRetrievers must implement abstract `_aget_relevant_documents` method instead of `aget_relevant_documents`run_manager>   selfqueryr8   r   r#   )super__init_subclass__get_relevant_documentsr(   warningswarnDeprecationWarning_get_relevant_documentshasattrr7   _aget_relevant_documentsr   
parametersgetr+   lensetkeysr,   )clsr1   swapaswaprD   	__class__s        r%   r<   zBaseRetriever.__init_subclass__   sM   !!++F+++ %)MMMM7"	    -D4 & +/C'C233	1+}/TTTM8"	    /E5 ' ,1C(s:;;F
!+!>!>d!J JOO%%&&)I)I)IIJJQN 	r$   r   c                    |                                  }|                    d          r|dd         }n|                    d          r
|dd         }|                                }t	          |          }|S )z Get standard params for tracing.	Retriever	   Ni)r   )get_name
startswithendswithlowerr   )r9   r1   default_retriever_name	ls_paramss       r%   _get_ls_paramszBaseRetriever._get_ls_params   s     "&!,,[99 	A%;ABB%?""#,,[99 	A%;CRC%@"!7!=!=!?!?,?UVVV	r$   inputr   configOptional[RunnableConfig]list[Document]c           	        ddl m} t          |          }i |                    d          pi  | j        di |}|                    |                    d          d|                    dd          |                    d          | j        || j        	          }|                    d||                    d
          p| 	                                |
                    dd                    }	 | j        r|ni }| j        r | j        |fd|i|}	n | j        |fi |}	|                    |	           |	S # t          $ r}
|                    |
           |
d}
~
ww xY w)a  Invoke the retriever to get relevant documents.

        Main entry point for synchronous retriever invocations.

        Args:
            input: The query string.
            config: Configuration for the retriever. Defaults to None.
            kwargs: Additional arguments to pass to the retriever.

        Returns:
            List of relevant documents.

        Examples:

        .. code-block:: python

            retriever.invoke("query")
        r   )CallbackManagerr0   	callbacksNverboseFr.   r^   inheritable_tags
local_tagsinheritable_metadatalocal_metadatarun_namerun_idnamere   r8   r#   ) langchain_core.callbacks.managerr\   r   rE   rV   	configurer.   r0   on_retriever_startrP   popr,   r+   rA   on_retriever_end	Exceptionon_retriever_error)r9   rW   rX   r1   r\   rb   callback_managerr8   _kwargsresultes              r%   invokezBaseRetriever.invoke   s   * 	EDDDDDv&& 
zz*%%+ 
!d!++F++ 
 +44JJ{##JJy%00#ZZ//y!5= 5 
 
 '99J'':4==??::h--	 : 
 
	 $ 8@ffbG& H55 '26=  65eGGwGG
 ((   M  	 	 	**1---G	s   11D9 9
EEEc           	       K   ddl m} t          |          }i |                    d          pi  | j        di |}|                    |                    d          d|                    dd          |                    d          | j        || j        	          }|                    d||                    d
          p| 	                                |
                    dd                     d{V }	 | j        r|ni }| j        r | j        |fd|i| d{V }	n | j        |fi | d{V }	|                    |	           d{V  |	S # t          $ r"}
|                    |
           d{V  |
d}
~
ww xY w)a  Asynchronously invoke the retriever to get relevant documents.

        Main entry point for asynchronous retriever invocations.

        Args:
            input: The query string.
            config: Configuration for the retriever. Defaults to None.
            kwargs: Additional arguments to pass to the retriever.

        Returns:
            List of relevant documents.

        Examples:

        .. code-block:: python

            await retriever.ainvoke("query")
        r   )AsyncCallbackManagerr0   r]   Nr^   Fr.   r_   rd   re   rf   r8   r#   )rh   ru   r   rE   rV   ri   r.   r0   rj   rP   rk   r,   r+   rC   rl   rm   rn   )r9   rW   rX   r1   ru   rb   ro   r8   rp   rq   rr   s              r%   ainvokezBaseRetriever.ainvoke  sX     0 	JIIIIIv&& 
zz*%%+ 
!d!++F++ 
 099JJ{##JJy%00#ZZ//y!5= : 
 
 -??J'':4==??::h--	 @ 
 
 
 
 
 
 
 
	 $ 8@ffbG& O<t<   '2 6=           =t<UNNgNNNNNNNN
 ..         M  	 	 	00333333333G	s   9=E 
E?E::E?r:   r8   r   c                   dS )zGet documents relevant to a query.

        Args:
            query: String to find relevant documents for.
            run_manager: The callback handler to use.
        Returns:
            List of relevant documents.
        Nr#   r9   r:   r8   s      r%   rA   z%BaseRetriever._get_relevant_documentsD  s      r$   r   c               f   K   t          d| j        ||                                           d{V S )zAsynchronously get documents relevant to a query.

        Args:
            query: String to find relevant documents for
            run_manager: The callback handler to use
        Returns:
            List of relevant documents
        N)r8   )r   rA   get_syncrx   s      r%   rC   z&BaseRetriever._aget_relevant_documentsQ  sX       %(#,,..	
 
 
 
 
 
 
 
 
 	
r$   z0.1.46rs   z1.0)sincealternativeremoval)r]   r.   r0   rd   r]   r   rd   r   c               \    i }|r||d<   |r||d<   |r||d<   |r||d<    | j         ||fi |S )a  Retrieve documents relevant to a query.

        Users should favor using `.invoke` or `.batch` rather than
        `get_relevant_documents directly`.

        Args:
            query: string to find relevant documents for.
            callbacks: Callback manager or list of callbacks. Defaults to None.
            tags: Optional list of tags associated with the retriever.
                These tags will be associated with each call to this retriever,
                and passed as arguments to the handlers defined in `callbacks`.
                Defaults to None.
            metadata: Optional metadata associated with the retriever.
                This metadata will be associated with each call to this retriever,
                and passed as arguments to the handlers defined in `callbacks`.
                Defaults to None.
            run_name: Optional name for the run. Defaults to None.
            kwargs: Additional arguments to pass to the retriever.

        Returns:
            List of relevant documents.
        r]   r.   r0   rd   )rs   r9   r:   r]   r.   r0   rd   r1   rX   s           r%   r=   z$BaseRetriever.get_relevant_documentsc  sm    B "$ 	,"+F; 	"!F6N 	*!)F: 	*!)F:t{5&33F333r$   rv   c               l   K   i }|r||d<   |r||d<   |r||d<   |r||d<    | j         ||fi | d{V S )a  Asynchronously get documents relevant to a query.

        Users should favor using `.ainvoke` or `.abatch` rather than
        `aget_relevant_documents directly`.

        Args:
            query: string to find relevant documents for.
            callbacks: Callback manager or list of callbacks.
            tags: Optional list of tags associated with the retriever.
                These tags will be associated with each call to this retriever,
                and passed as arguments to the handlers defined in `callbacks`.
                Defaults to None.
            metadata: Optional metadata associated with the retriever.
                This metadata will be associated with each call to this retriever,
                and passed as arguments to the handlers defined in `callbacks`.
                Defaults to None.
            run_name: Optional name for the run. Defaults to None.
            kwargs: Additional arguments to pass to the retriever.

        Returns:
            List of relevant documents.
        r]   r.   r0   rd   N)rv   r   s           r%   r7   z%BaseRetriever.aget_relevant_documents  s      B "$ 	,"+F; 	"!F6N 	*!)F: 	*!)F:!T\%::6:::::::::r$   )r1   r   r2   r3   )r1   r   r2   r   )N)rW   r   rX   rY   r1   r   r2   rZ   )r:   r   r8   r   r2   rZ   )r:   r   r8   r   r2   rZ   )r:   r   r]   r   r.   r-   r0   r/   rd   r   r1   r   r2   rZ   )r   r   r    r!   r
   model_configr+   r"   r,   r.   r0   r<   rV   rs   rv   r   rA   rC   r   r=   r7   __classcell__)rL   s   @r%   r(   r(   D   s        : :x : $  L  %$$$$ %%%%% $D$$$$ *.H----$
 $
 $
 $
 $
 $
L    >B: : : : :~ ,0= = = = =~ 
 
 
 ^

 
 
 
$ ZhHeDDD
  $$(-1"&)4 )4 )4 )4 )4 ED)4V ZhIuEEE
  $$(-1"&); ); ); ); ); FE); ); ); ); );r$   r(   )(r!   
__future__r   r>   abcr   r   inspectr   typingr   r   r	   pydanticr
   typing_extensionsr   langchain_core._apir   langchain_core.documentsr   langchain_core.runnablesr   r   r   r   langchain_core.runnables.configr   rh   r   r   r   r   RetrieverInputlistRetrieverOutputRetrieverLikeRetrieverOutputLiker   r(   r#   r$   r%   <module>r      s   * # " " " " "  # # # # # # # #       / / / / / / / / / /       ' ' ' ' ' ' * * * * * * - - - - - -            < ; ; ; ; ;           x.89sO34 
 
 
 
 
y 
 
 
 
u; u; u; u; u;()HI3 u; u; u; u; u;r$   