Ng'dZddlmZddlZddlZddlZddlmZddlm Z m Z m Z m Z m Z mZddlmZddlmZmZddlmZdd lmZejd ZddZd dZd!dZd"dZd#dZGddeZdS)$a!Module contains code for a cache backed embedder. The cache backed embedder is a wrapper around an embedder that caches embeddings in a key-value store. The cache is used to avoid recomputing embeddings for the same text. The text is hashed and the hash is used as the key in the cache. ) annotationsN)partial)CallableListOptionalSequenceUnioncast) Embeddings) BaseStore ByteStore) batch_iterate)EncoderBackedStorei)int input_stringstrreturn uuid.UUIDctj|d}t jt |S)z1Hash a string and returns the corresponding UUID.zutf-8)hashlibsha1encode hexdigestuuiduuid5NAMESPACE_UUID)r hash_values V/var/www/html/ai-engine/env/lib/python3.11/site-packages/langchain/embeddings/cache.py_hash_string_to_uuidrs=l11'::;;EEGGJ :nj 1 11key namespacec@|tt|zS)z Encode a key.)rr)r!r"s r _key_encoderr$!s s/4455 55r Callable[[str], str]c.tt|S)zCreate an encoder for a key.r")rr$r's r_create_key_encoderr(&s <9 5 5 55r valueSequence[float]bytescNtj|S)zSerialize a value.)jsondumpsr)r)s r_value_serializerr/+s :e   # # % %%r serialized_value List[float]cttttj|S)zDeserialize a value.)r rfloatr-loadsdecode)r0s r_value_deserializerr60s- U TZ(8(?(?(A(ABB C CCr cneZdZdZdddd"fdZd#dZd#dZd$dZd$dZe ddddd%d!Z xZ S)&CacheBackedEmbeddingsaInterface for caching results from embedding models. The interface allows works with any store that implements the abstract store interface accepting keys of type str and values of list of floats. If need be, the interface can be extended to accept other implementations of the value serializer and deserializer, as well as the key encoder. Note that by default only document embeddings are cached. To cache query embeddings too, pass in a query_embedding_store to constructor. Examples: .. code-block: python from langchain.embeddings import CacheBackedEmbeddings from langchain.storage import LocalFileStore from langchain_community.embeddings import OpenAIEmbeddings store = LocalFileStore('./my_cache') underlying_embedder = OpenAIEmbeddings() embedder = CacheBackedEmbeddings.from_bytes_store( underlying_embedder, store, namespace=underlying_embedder.model ) # Embedding is computed and cached embeddings = embedder.embed_documents(["hello", "goodbye"]) # Embeddings are retrieved from the cache, no computation is done embeddings = embedder.embed_documents(["hello", "goodbye"]) N batch_sizequery_embedding_storeunderlying_embeddingsr document_embedding_storeBaseStore[str, List[float]]r: Optional[int]r;%Optional[BaseStore[str, List[float]]]rNonect||_||_||_||_dS)aInitialize the embedder. Args: underlying_embeddings: the embedder to use for computing embeddings. document_embedding_store: The store to use for caching document embeddings. batch_size: The number of documents to embed between store updates. query_embedding_store: The store to use for caching query embeddings. If None, query embeddings are not cached. N)super__init__r=r;r<r:)selfr<r=r:r; __class__s rrDzCacheBackedEmbeddings.__init__Xs>" (@%%:"%:"$r texts List[str]List[List[float]]c |j}dt|D}t|j|D]z}fd|D}|j|}|jtt||t||D] \}}|||< {tttt|S)wEmbed a list of texts. The method first checks the cache for the embeddings. If the embeddings are not found, the method uses the underlying embedder to embed the documents and stores the results in the cache. Args: texts: A list of texts to embed. Returns: A list of embeddings for the given texts. cg|] \}}|| SN.0ivectors r z9CacheBackedEmbeddings.embed_documents..$* * * !VV^A^^^r c g|] }| SrNrNrPrQrGs rrSz9CacheBackedEmbeddings.embed_documents..???!U1X???r ) r=mget enumeraterr:r<embed_documentsmsetlistzipr rr3 rErGvectorsall_missing_indicesmissing_indices missing_textsmissing_vectorsindexupdated_vectors ` rrZz%CacheBackedEmbeddings.embed_documentsos372O2T2T 3 3 * * (11* * *  -T_>QRR 0 0O???????M"8HHWWO  ) . .S8899   *-_o)N)N 0 0%~!/ 0 e w   r c K|jd{V}dt|D}t|j|D]}fd|D}|j|d{V}|jtt||d{Vt||D] \}}|||< tttt|S)rKNcg|] \}}|| SrMrNrOs rrSz:CacheBackedEmbeddings.aembed_documents..rTr c g|] }| SrNrNrVs rrSz:CacheBackedEmbeddings.aembed_documents..rWr ) r=amgetrYrr:r<aembed_documentsamsetr\r]r rr3r^s ` rrjz&CacheBackedEmbeddings.aembed_documentssm/55e<< < < < < < < * * (11* * *  -T_>QRR 0 0O???????M$($>$O$O%%O/55S8899       *-_o)N)N 0 0%~!/ 0 e w   r textrr1c|js|j|S|j|g\}||S|j|}|j||fg|S),Embed query text. By default, this method does not cache queries. To enable caching, set the `cache_query` parameter to `True` when initializing the embedder. Args: text: The text to embed. Returns: The embedding for the given text. )r;r< embed_queryrXr[rErlcachedrRs rroz!CacheBackedEmbeddings.embed_querys) @-99$?? ?.33TF;;   M+77== "''$(8999 r c,K|js |j|d{VS|j|gd{V\}||S|j|d{V}|j||fgd{V|S)rnN)r;r< aembed_queryrirkrps rrsz"CacheBackedEmbeddings.aembed_querys) G3@@FFFFFFFF F4::D6BBBBBBBB   M1>>tDDDDDDDD(..v/?@@@@@@@@@ r F)r"r:query_embedding_cachedocument_embedding_cacher r"ruUnion[bool, ByteStore]cB|}t|}ttttf||t t }|dur|}n@|durd}n9ttttf||t t }|||||S)aOn-ramp that adds the necessary serialization and encoding to the store. Args: underlying_embeddings: The embedder to use for embedding. document_embedding_cache: The cache to use for storing document embeddings. *, namespace: The namespace to use for document cache. This namespace is used to avoid collisions with other caches. For example, set it to the name of the embedding model used. batch_size: The number of documents to embed between store updates. query_embedding_cache: The cache to use for storing query embeddings. True to use the same cache as document embeddings. False to not cache query embeddings. TFNr9)r(rrrr3r/r6) clsr<rvr"r:ru key_encoderr=r;s rfrom_bytes_storez&CacheBackedEmbeddings.from_bytes_stores0 ))44 #5c4;6F#G $    $ $  !D ( ($< ! ! "e + +$( ! !$6sDK7G$H%!# %% !s ! $!"7     r ) r<r r=r>r:r?r;r@rrA)rGrHrrI)rlrrr1) r<r rvr r"rr:r?rurwrr8) __name__ __module__ __qualname____doc__rDrZrjrors classmethodr{ __classcell__)rFs@rr8r85s  N%)GK %%%%%%%%.    B# # # # J.. $(8=0 0 0 0 0 [0 0 0 0 0 r r8)rrrr)r!rr"rrr)r"rrr%)r)r*rr+)r0r+rr1) r __future__rrr-r functoolsrtypingrrrrr r langchain_core.embeddingsr langchain_core.storesr r langchain_core.utils.iterr langchain.storage.encoder_backedrUUIDrrr$r(r/r6r8rNr rrs#""""" BBBBBBBBBBBBBBBB00000066666666333333??????t$$$2222 6666 6666 &&&& DDDD _ _ _ _ _ J_ _ _ _ _ r