Q idZddlmZmZmZmZmZmZmZddl m Z ddl m Z ddl mZmZddlmZmZddlmZeeZGdd e Zd S) z,Embeddings cache implementation for RedisVL.)AnyDictIterableListOptionalTupleUnion) BaseCache) CacheEntry) convert_byteshashify)AsyncRedisClientSyncRedisClient) get_loggercNeZdZUdZdZeed<dddddifdedee d ee d ee d ed e ee ff fd ZdeeefdedefdZdeeefdedefdZ d9deeefdedeedee ee fdeee ee fff dZdee ee fdee ee ffdZdefdZdeeefdedee ee ffdZdedee ee ffdZdeedeee ee ffdZdeeeefdedeee ee ffdZ d:deeefdedeedee ee fdee def d Z d9d!ee ee fdee deefd"Zdeeefdedefd#Z dedefd$Z!deedeefd%Z"deeeefdedeefd&Z#deeefdeddfd'Z$deddfd(Z%deeddfd)Z&deeeefdeddfd*Z'deeefdedee ee ffd+Z(dedee ee ffd,Z)deedeee ee ffd-Z*deeeefdedeee ee ffd.Z+ d:deeefdedeedee ee fdee def d/Z, d9d!ee ee fdee deefd0Z-deedeefd1Z.deeeefdedeefd2Z/deeddfd3Z0deeeefdeddfd4Z1deeefdedefd5Z2dedefd6Z3deeefdeddfd7Z4deddfd8Z5xZ6S);EmbeddingsCachezGEmbeddings Cache for storing embedding vectors with exact key matching.F_warning_shown embedcacheNzredis://localhost:6379namettl redis_clientasync_redis_client redis_urlconnection_kwargscVt||||||dS)aInitialize an embeddings cache. Args: name (str): The name of the cache. Defaults to "embedcache". ttl (Optional[int]): The time-to-live for cached embeddings. Defaults to None. redis_client (Optional[SyncRedisClient]): Redis client instance. Defaults to None. redis_url (str): Redis URL for connection. Defaults to "redis://localhost:6379". connection_kwargs (Dict[str, Any]): Redis connection arguments. Defaults to {}. Raises: ValueError: If vector dimensions are invalid .. code-block:: python cache = EmbeddingsCache( name="my_embeddings_cache", ttl=3600, # 1 hour redis_url="redis://localhost:6379" ) )rrrrrrN)super__init__)selfrrrrrr __class__s C:\Users\Dell Inspiron 16\Desktop\tws\AgrotaPowerBi\back-agrota-powerbi\mcp-client-agrota\venv\Lib\site-packages\redisvl/extensions/cache/embeddings/embeddings.pyrzEmbeddingsCache.__init__sB: %1/      content model_namereturnc|t|tr|}t|d|S)aAGenerate a deterministic entry ID for the given content and model name. Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. Returns: str: A deterministic entry ID based on the content and model name. :) isinstancebyteshexr )rr"r#s r _make_entry_idzEmbeddingsCache._make_entry_id9s? gu % % $kkmmG'00J00111r!cX|||}||S)aGenerate a full Redis key for the given content and model name. Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. Returns: str: The full Redis key. )r* _make_key)rr"r#entry_ids r _make_cache_keyzEmbeddingsCache._make_cache_keyGs+&&w ;;~~h'''r! embeddingmetadatac|||}||}t|||||}||fS)aPrepare data for storage in Redis Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. embedding (List[float]): The embedding vector. metadata (Optional[Dict[str, Any]]): Optional metadata. Returns: Tuple[str, Dict[str, Any]]: A tuple of (key, entry_data) )r-r"r#r/r0)r*r,r to_dict)rr"r#r/r0r-keyentrys r _prepare_entry_dataz#EmbeddingsCache._prepare_entry_dataTsb&&&w ;;nnX&&!    EMMOO##r!datach|sdStdit|}|dS)zProcess Redis hash data into a cache entry response. Args: data (Optional[Dict[str, Any]]): Raw Redis hash data. Returns: Optional[Dict[str, Any]]: Processed cache entry or None if no data. NT) exclude_none)r r model_dump)rr6 cache_hits r _process_cache_dataz#EmbeddingsCache._process_cache_datarsC 455t!4!455 ###666r!c&|jduo|jduS)zCheck if only async client is available (no sync client). Returns: bool: True if only async client is available (no sync client). FN)_owns_redis_client _redis_client)rs r _should_warn_for_async_onlyz+EmbeddingsCache._should_warn_for_async_onlys &%/ND4F$4NNr!cX|||}||S)acGet embedding by content and model name. Retrieves a cached embedding for the given content and model name. If found, refreshes the TTL of the entry. Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. Returns: Optional[Dict[str, Any]]: Embedding cache entry or None if not found. .. code-block:: python embedding_data = cache.get( content="What is machine learning?", model_name="text-embedding-ada-002" ) )r. get_by_keyrr"r#r3s r getzEmbeddingsCache.gets+0""7J77s###r!r3c8|r2tjs&tddt_|}||}|r||||S)aGet embedding by its full Redis key. Retrieves a cached embedding for the given Redis key. If found, refreshes the TTL of the entry. Args: key (str): The full Redis key for the embedding. Returns: Optional[Dict[str, Any]]: Embedding cache entry or None if not found. .. code-block:: python embedding_data = cache.get_by_key("embedcache:1234567890abcdef") zEmbeddingsCache initialized with async_redis_client only. Use async methods (aget_by_key) instead of sync methods (get_by_key).T) r@rrloggerwarning_get_redis_clienthgetallexpirer<rr3clientr6s r rBzEmbeddingsCache.get_by_keys  + + - - 6"1 6\26.''))~~c""   KK   ''---r!keysc2|sgS|r2tjs&tddt_|}|d5}|D]}|||}dddn #1swxYwYg}t|D]J\}}|r| ||| | |K|S)aGet multiple embeddings by their Redis keys. Efficiently retrieves multiple cached embeddings in a single network roundtrip. If found, refreshes the TTL of each entry. Args: keys (List[str]): List of Redis keys to retrieve. Returns: List[Optional[Dict[str, Any]]]: List of embedding cache entries or None for keys not found. The order matches the input keys order. .. code-block:: python # Get multiple embeddings embedding_data = cache.mget_by_keys([ "embedcache:key1", "embedcache:key2" ]) zEmbeddingsCache initialized with async_redis_client only. Use async methods (amget_by_keys) instead of sync methods (mget_by_keys).TF transactionN) r@rrrFrGrHpipelinerIexecute enumeraterJappendr< rrMrLrQr3resultsprocessed_resultsiresults r mget_by_keyszEmbeddingsCache.mget_by_keyssr* I  + + - - 6"1 6`26.'')) ___ / / )8 & &  %%%%&&((G  ) ) ) ) ) ) ) ) ) ) ) ) ) ) )"7++ G GIAv % DG$$$  $ $T%=%=f%E%E F F F F  s5/B00B47B4contentscVfd|D}|sgS|S)aGet multiple embeddings by their content and model name. Efficiently retrieves multiple cached embeddings in a single operation. If found, refreshes the TTL of each entry. Args: contents (Iterable[bytes | str]): Iterable of content that was embedded. model_name (str): The name of the embedding model. Returns: List[Optional[Dict[str, Any]]]: List of embedding cache entries or None for contents not found. .. code-block:: python # Get multiple embeddings embedding_data = cache.mget( contents=["What is machine learning?", "What is deep learning?"], model_name="text-embedding-ada-002" ) c<g|]}|Sr9r..0r"r#rs r z(EmbeddingsCache.mget..)RRRg$$Wj99RRRr!)rZrr[r#rMs` ` r mgetzEmbeddingsCache.mgetsF0SRRRRRRR I  &&&r!cJ|||||\}}|r2tjs&tddt_|}|||||||S)a,Store an embedding with its content and model name. Args: content (Union[bytes, str]): The content to be embedded. model_name (str): The name of the embedding model. embedding (List[float]): The embedding vector to store. metadata (Optional[Dict[str, Any]]): Optional metadata to store with the embedding. ttl (Optional[int]): Optional TTL override for this specific entry. Returns: str: The Redis key where the embedding was stored. .. code-block:: python key = cache.set( content="What is machine learning?", model_name="text-embedding-ada-002", embedding=[0.1, 0.2, 0.3, ...], metadata={"source": "user_query"} ) zqEmbeddingsCache initialized with async_redis_client only. Use async methods (aset) instead of sync methods (set).Trmapping) r5r@rrrFrGrHhsetrJ rr"r#r/r0rr3 cache_entryrLs r setzEmbeddingsCache.sets< 33 ZH  [  + + - - 6"1 6N26.'')) k 222 C r!itemsc|sgS|r2tjs&tddt_|}g}|d5}|D]>}|jdi|\}}||| ||?| dddn #1swxYwY|D]}| |||S)aStore multiple embeddings in a batch operation. Each item in the input list should be a dictionary with the following fields: - 'content': The input that was embedded - 'model_name': The name of the embedding model - 'embedding': The embedding vector - 'metadata': Optional metadata to store with the embedding Args: items: List of dictionaries, each containing content, model_name, embedding, and optional metadata. ttl: Optional TTL override for these entries. Returns: List[str]: List of Redis keys where the embeddings were stored. .. code-block:: python # Store multiple embeddings keys = cache.mset([ { "content": "What is ML?", "model_name": "text-embedding-ada-002", "embedding": [0.1, 0.2, 0.3], "metadata": {"source": "user"} }, { "content": "What is AI?", "model_name": "text-embedding-ada-002", "embedding": [0.4, 0.5, 0.6], "metadata": {"source": "docs"} } ]) zsEmbeddingsCache initialized with async_redis_client only. Use async methods (amset) instead of sync methods (mset).TFrOrfNr9) r@rrrFrGrHrQr5rTrhrRrJ rrlrrLrMrQitemr3rjs r msetzEmbeddingsCache.msetMsiL I  + + - - 6"1 6P26.'')) ___ / / 8 = =#;4#;#C#Cd#C#C [ C    3 <<<<                      " "C KKS ! ! ! ! s7ACC Cc|}|||}t||S)aCheck if an embedding exists for the given content and model. Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. Returns: bool: True if the embedding exists in the cache, False otherwise. .. code-block:: python if cache.exists("What is machine learning?", "text-embedding-ada-002"): print("Embedding is in cache") )rHr.boolexists)rr"r#rLr3s r rszEmbeddingsCache.existssD''))""7J77FMM#&&'''r!cn|}t||S)a}Check if an embedding exists for the given Redis key. Args: key (str): The full Redis key for the embedding. Returns: bool: True if the embedding exists in the cache, False otherwise. .. code-block:: python if cache.exists_by_key("embedcache:1234567890abcdef"): print("Embedding is in cache") )rHrrrsrr3rLs r exists_by_keyzEmbeddingsCache.exists_by_keys/''))FMM#&&'''r!c|sgS|}|d5}|D]}|||}dddn #1swxYwYd|DS)aCheck if multiple embeddings exist by their Redis keys. Efficiently checks existence of multiple keys in a single operation. Args: keys (List[str]): List of Redis keys to check. Returns: List[bool]: List of boolean values indicating whether each key exists. The order matches the input keys order. .. code-block:: python # Check if multiple keys exist exists_results = cache.mexists_by_keys(["embedcache:key1", "embedcache:key2"]) FrONc,g|]}t|Sr9rrr`rYs r raz3EmbeddingsCache.mexists_by_keys..333V 333r!)rHrQrsrRrrMrLrQr3rVs r mexists_by_keyszEmbeddingsCache.mexists_by_keyss" I'')) ___ / / )8 % %$$$$&&((G  ) ) ) ) ) ) ) ) ) ) ) ) ) ) )4373333s/A**A.1A.cVfd|D}|sgS|S)aCheck if multiple embeddings exist by their contents and model name. Efficiently checks existence of multiple embeddings in a single operation. Args: contents (Iterable[bytes | str]): Iterable of content that was embedded. model_name (str): The name of the embedding model. Returns: List[bool]: List of boolean values indicating whether each embedding exists. .. code-block:: python # Check if multiple embeddings exist exists_results = cache.mexists( contents=["What is machine learning?", "What is deep learning?"], model_name="text-embedding-ada-002" ) c<g|]}|Sr9r^r_s r raz+EmbeddingsCache.mexists..rbr!)r}rcs` ` r mexistszEmbeddingsCache.mexistssF.SRRRRRRR I##D)))r!c\|||}||dS)alRemove an embedding from the cache. Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. .. code-block:: python cache.drop( content="What is machine learning?", model_name="text-embedding-ada-002" ) N)r. drop_by_keyrCs r dropzEmbeddingsCache.drops3""7J77 r!cX|}||dS)zRemove an embedding from the cache by its Redis key. Args: key (str): The full Redis key for the embedding. .. code-block:: python cache.drop_by_key("embedcache:1234567890abcdef") N)rHdeleterus r rzEmbeddingsCache.drop_by_keys-'')) cr!c|sdS|}|d5}|D]}|||ddddS#1swxYwYdS)alRemove multiple embeddings from the cache by their Redis keys. Efficiently removes multiple embeddings in a single operation. Args: keys (List[str]): List of Redis keys to remove. .. code-block:: python # Remove multiple embeddings cache.mdrop_by_keys(["embedcache:key1", "embedcache:key2"]) NFrO)rHrQrrR)rrMrLrQr3s r mdrop_by_keyszEmbeddingsCache.mdrop_by_keyss  F'')) ___ / / 8 % %$$$$                        s/A++A/2A/cZfd|D}|sdS|dS)a6Remove multiple embeddings from the cache by their contents and model name. Efficiently removes multiple embeddings in a single operation. Args: contents (Iterable[bytes | str]): Iterable of content that was embedded. model_name (str): The name of the embedding model. .. code-block:: python # Remove multiple embeddings cache.mdrop( contents=["What is machine learning?", "What is deep learning?"], model_name="text-embedding-ada-002" ) c<g|]}|Sr9r^r_s r raz)EmbeddingsCache.mdrop..:rbr!N)rrcs` ` r mdropzEmbeddingsCache.mdrop(sL$SRRRRRRR  F 4     r!chK|||}||d{VS)aAsync get embedding by content and model name. Asynchronously retrieves a cached embedding for the given content and model name. If found, refreshes the TTL of the entry. Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. Returns: Optional[Dict[str, Any]]: Embedding cache entry or None if not found. .. code-block:: python embedding_data = await cache.aget( content="What is machine learning?", model_name="text-embedding-ada-002" ) N)r. aget_by_keyrCs r agetzEmbeddingsCache.agetBsC0""7J77%%c*********r!cK|d{V}||d{V}|r||d{V||S)aAsync get embedding by its full Redis key. Asynchronously retrieves a cached embedding for the given Redis key. If found, refreshes the TTL of the entry. Args: key (str): The full Redis key for the embedding. Returns: Optional[Dict[str, Any]]: Embedding cache entry or None if not found. .. code-block:: python embedding_data = await cache.aget_by_key("embedcache:1234567890abcdef") N)_get_async_redis_clientrIaexpirer<rKs r rzEmbeddingsCache.aget_by_key]s 3355555555^^C((((((((  $,,s## # # # # # # #''---r!cK|sgS|d{V}|d4d{V}|D]}|||d{V}dddd{Vn#1d{VswxYwYg}t |D]P\}}|r!|||d{V|||Q|S)aAsync get multiple embeddings by their Redis keys. Asynchronously retrieves multiple cached embeddings in a single network roundtrip. If found, refreshes the TTL of each entry. Args: keys (List[str]): List of Redis keys to retrieve. Returns: List[Optional[Dict[str, Any]]]: List of embedding cache entries or None for keys not found. The order matches the input keys order. .. code-block:: python # Get multiple embeddings asynchronously embedding_data = await cache.amget_by_keys([ "embedcache:key1", "embedcache:key2" ]) NFrO)rrQrIrRrSrrTr<rUs r amget_by_keyszEmbeddingsCache.amget_by_keysxs* I3355555555??u?55 / / / / / / / & &  %%%%$,,........G  / / / / / / / / / / / / / / / / / / / / / / / / / / /"7++ G GIAv ,ll47+++++++++  $ $T%=%=f%E%E F F F F  s5B BBcfKfd|D}|sgS|d{VS)a Async get multiple embeddings by their contents and model name. Asynchronously retrieves multiple cached embeddings in a single operation. If found, refreshes the TTL of each entry. Args: contents (Iterable[bytes | str]): Iterable of content that was embedded. model_name (str): The name of the embedding model. Returns: List[Optional[Dict[str, Any]]]: List of embedding cache entries or None for contents not found. .. code-block:: python # Get multiple embeddings asynchronously embedding_data = await cache.amget( contents=["What is machine learning?", "What is deep learning?"], model_name="text-embedding-ada-002" ) c<g|]}|Sr9r^r_s r raz)EmbeddingsCache.amget..rbr!N)rrcs` ` r amgetzEmbeddingsCache.amgets\0SRRRRRRR I''---------r!cK|||||\}}|d{V}|||d{V|||d{V|S)aAsync store an embedding with its content and model name. Asynchronously stores an embedding with its content and model name. Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. embedding (List[float]): The embedding vector to store. metadata (Optional[Dict[str, Any]]): Optional metadata to store with the embedding. ttl (Optional[int]): Optional TTL override for this specific entry. Returns: str: The Redis key where the embedding was stored. .. code-block:: python key = await cache.aset( content="What is machine learning?", model_name="text-embedding-ada-002", embedding=[0.1, 0.2, 0.3, ...], metadata={"source": "user_query"} ) Nrf)r5rrhrris r asetzEmbeddingsCache.asets@ 33 ZH  [ 3355555555kksKk888888888ll3$$$$$$$$$ r!cK|sgS|d{V}g}|d4d{V}|D]D}|jdi|\}}|||||d{VE|d{Vdddd{Vn#1d{VswxYwY|D]}|||d{V|S)aAsync store multiple embeddings in a batch operation. Each item in the input list should be a dictionary with the following fields: - 'content': The content that was embedded - 'model_name': The name of the embedding model - 'embedding': The embedding vector - 'metadata': Optional metadata to store with the embedding Args: items: List of dictionaries, each containing content, model_name, embedding, and optional metadata. ttl: Optional TTL override for these entries. Returns: List[str]: List of Redis keys where the embeddings were stored. .. code-block:: python # Store multiple embeddings asynchronously keys = await cache.amset([ { "content": "What is ML?", "model_name": "text-embedding-ada-002", "embedding": [0.1, 0.2, 0.3], "metadata": {"source": "user"} }, { "content": "What is AI?", "model_name": "text-embedding-ada-002", "embedding": [0.4, 0.5, 0.6], "metadata": {"source": "docs"} } ]) NFrOrfr9)rrQr5rTrhrRrrns r amsetzEmbeddingsCache.amsetsL I3355555555??u?55 % % % % % % % C C#;4#;#C#Cd#C#C [ C   mmkmBBBBBBBBBB""$$ $ $ $ $ $ $ $ % % % % % % % % % % % % % % % % % % % % % % % % % % % ) )C,,sC(( ( ( ( ( ( ( ( ( sA"B33 B=B=cNK|sgS|d{V}|d4d{V}|D]}||d{V|d{V}dddd{Vn#1d{VswxYwYd|DS)a7Async check if multiple embeddings exist by their Redis keys. Asynchronously checks existence of multiple keys in a single operation. Args: keys (List[str]): List of Redis keys to check. Returns: List[bool]: List of boolean values indicating whether each key exists. The order matches the input keys order. .. code-block:: python # Check if multiple keys exist asynchronously exists_results = await cache.amexists_by_keys(["embedcache:key1", "embedcache:key2"]) NFrOc,g|]}t|Sr9ryrzs r raz4EmbeddingsCache.amexists_by_keys..Hr{r!)rrQrsrRr|s r amexists_by_keysz EmbeddingsCache.amexists_by_keys+sg" I3355555555??u?55 / / / / / / / + +ooc**********$,,........G  / / / / / / / / / / / / / / / / / / / / / / / / / / /4373333s;B  BBcfKfd|D}|sgS|d{VS)aAsync check if multiple embeddings exist by their contents and model name. Asynchronously checks existence of multiple embeddings in a single operation. Args: contents (Iterable[bytes | str]): Iterable of content that was embedded. model_name (str): The name of the embedding model. Returns: List[bool]: List of boolean values indicating whether each embedding exists. .. code-block:: python # Check if multiple embeddings exist asynchronously exists_results = await cache.amexists( contents=["What is machine learning?", "What is deep learning?"], model_name="text-embedding-ada-002" ) c<g|]}|Sr9r^r_s r raz,EmbeddingsCache.amexists..arbr!N)rrcs` ` r amexistszEmbeddingsCache.amexistsJs\.SRRRRRRR I**4000000000r!cfK|sdS|d{V}|j|d{VdS)aAsync remove multiple embeddings from the cache by their Redis keys. Asynchronously removes multiple embeddings in a single operation. Args: keys (List[str]): List of Redis keys to remove. .. code-block:: python # Remove multiple embeddings asynchronously await cache.amdrop_by_keys(["embedcache:key1", "embedcache:key2"]) Nrr)rrMrLs r amdrop_by_keyszEmbeddingsCache.amdrop_by_keysis_  F3355555555fmT""""""""""r!cjKfd|D}|sdS|d{VdS)aUAsync remove multiple embeddings from the cache by their contents and model name. Asynchronously removes multiple embeddings in a single operation. Args: contents (Iterable[bytes | str]): Iterable of content that was embedded. model_name (str): The name of the embedding model. .. code-block:: python # Remove multiple embeddings asynchronously await cache.amdrop( contents=["What is machine learning?", "What is deep learning?"], model_name="text-embedding-ada-002" ) c<g|]}|Sr9r^r_s r raz*EmbeddingsCache.amdrop..rbr!N)rrcs` ` r amdropzEmbeddingsCache.amdrop|sb(SRRRRRRR  F!!$'''''''''''r!chK|||}||d{VS)aAsync check if an embedding exists. Asynchronously checks if an embedding exists for the given content and model. Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. Returns: bool: True if the embedding exists in the cache, False otherwise. .. code-block:: python if await cache.aexists("What is machine learning?", "text-embedding-ada-002"): print("Embedding is in cache") N)r.aexists_by_keyrCs r aexistszEmbeddingsCache.aexistssC"""7J77((---------r!cK|d{V}t||d{VS)aAsync check if an embedding exists for the given Redis key. Asynchronously checks if an embedding exists for the given Redis key. Args: key (str): The full Redis key for the embedding. Returns: bool: True if the embedding exists in the cache, False otherwise. .. code-block:: python if await cache.aexists_by_key("embedcache:1234567890abcdef"): print("Embedding is in cache") N)rrrrsrus r rzEmbeddingsCache.aexists_by_keysW 3355555555&--,,,,,,,,---r!clK|||}||d{VdS)aAsync remove an embedding from the cache. Asynchronously removes an embedding from the cache. Args: content (bytes | str): The content that was embedded. model_name (str): The name of the embedding model. .. code-block:: python await cache.adrop( content="What is machine learning?", model_name="text-embedding-ada-002" ) N)r. adrop_by_keyrCs r adropzEmbeddingsCache.adropsI ""7J77$$$$$$$$$$$r!ctK|d{V}||d{VdS)aBAsync remove an embedding from the cache by its Redis key. Asynchronously removes an embedding from the cache by its Redis key. Args: key (str): The full Redis key for the embedding. .. code-block:: python await cache.adrop_by_key("embedcache:1234567890abcdef") Nrrus r rzEmbeddingsCache.adrop_by_keysU3355555555mmC           r!)N)NN)7__name__ __module__ __qualname____doc__rrr__annotations__strrintrrrrrr r(r*r.rfloatrr5r<r@rDrBrZrrdrkrprsrvr}rrrrrrrrrrrrrrrrrrr __classcell__)rs@r rrslQQ ND   !!269=1,.$ $ $ c]$ / $ %%56 $  $  S>$ $ $ $ $ $ L 2eE3J&7 2S 2S 2 2 2 2 (uUCZ'8 (c (c ( ( ( ($.2 $$ucz"$$; $ 4S>* $ sDcN" # $$$$<7T#s(^,7 $sCx. !7777"OTOOOO$ucz"$$ $sCx. ! $$$$6!.c!.htCH~&>!.!.!.!.F/!c/!tHT#s(^4L/M/!/!/!/!b' ucz!23'AD' htCH~& '''''J.2! 11ucz"11; 1 4S>* 1 c] 1 1111l"BBDcN#Bc]B c BBBBH(eE3J/(S(T((((&(((((("4DI4$t*4444>* ucz!23*AD* d****>E%*-34" s t    $s).!huUCZ'89!s!t!!!!4+ucz"++ $sCx. ! ++++6.S.Xd38n-E....6(!S (!d8DcN;S6T(!(!(!(!T. ucz!23.AD. htCH~& '....J.2! ++ucz"++; + 4S>* + c] + ++++`"::DcN#:c]: c ::::x4494d4444>1 ucz!231AD1 d1111>#c#t####&( ucz!23(AD( ((((8.U5#:%6.C.D....(......&%5#4%#%$%%%%& !c !d ! ! ! ! ! ! ! !r!rN)rtypingrrrrrrr redisvl.extensions.cache.baser *redisvl.extensions.cache.embeddings.schemar redisvl.redis.utilsr r redisvl.typesrrredisvl.utils.logrrrFrr9r!r rs22DDDDDDDDDDDDDDDDDD333333AAAAAA66666666;;;;;;;;(((((( H  Q!Q!Q!Q!Q!iQ!Q!Q!Q!Q!r!