Q i^N ddlZddlZddlZddlZddlZddlZddlmZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZddlZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"ddl#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.m/Z/m0Z0dd l1m2Z2m3Z3m4Z4e rdd l5m6Z6dd l7m8Z8ddl9m:Z:ddl!m;Z;ddlmm?Z?ddl@mAZAe=jBdrddlCmDZDnddlEmDZDddl9m:Z:ddlFmGZGmHZHmIZImJZJmKZKddlLmMZMmNZNmOZOddlPmQZQm;Z;mRZRmSZSmTZTmUZUddlVmWZWddlXmYZYddlZm[Z[m\Z\m]Z]m^Z^ddl_m`Z`ddlambZbmcZcddldmeZemfZfmgZgmhZhddlimjZjejekZldZmd d!d"d#d!d"gZneeeeoe;fee eoeeoepeqerffdffeeoe;ffZsd$d%d&e;d'ebd(ee eoe ffd)Ztd$d*d&eQd+ecd(ee eoe ffd,ZuGd-d.ZvGd/d0evZwGd1d2evZxdS)3N)ceil) TYPE_CHECKINGAnyAsyncGeneratorCallableDict GeneratorIterableListOptionalSequenceTupleUnioncast)Redis) RedisCluster HybridQuery) VectorQuery)SQLQuery)_keys_share_hash_tagasync_cluster_create_indexasync_cluster_searchcluster_create_indexcluster_search convert_bytes make_dict)AsyncRedisClientSyncRedisClientSyncRedisCluster)deprecated_argumentdeprecated_function sync_wrapper)AggregateResult)Document)Result) BaseQuery) __version__) NEVER_DECODE)get_protocol_version5)IndexDefinition)QueryValidationErrorRedisModuleVersionErrorRedisSearchError RedisVLErrorSchemaValidationError) BaseStorage HashStorage JsonStorage)AggregationQueryr'BaseVectorQuery CountQuery FilterQuery TextQuery)AggregateHybridQuery)FilterExpression)RedisConnectionFactoryconvert_index_info_to_schema supports_svssupports_svs_async)SVS_MIN_REDIS_VERSION) IndexSchema StorageType)VECTOR_NORM_MAPSVSVectorFieldVectorDistanceMetricVectorIndexAlgorithm) get_loggerz`Hybrid search is not available in this version of redis-py. Please upgrade to redis-py >= 7.1.0.searchiJQ)namever searchlightresultsr&queryschemareturnc<ttr|jS|jjt jkottoj ttryj rrt|j j jj}|tjkrt%jdt(|jnddddt,t.t0fffd fd|jDS)aConvert a list of search Result objects into a list of document dictionaries. This function processes results from Redis, handling different storage types and query types. For JSON storage with empty return fields, it unpacks the JSON object while retaining the document ID. The 'payload' field is also removed from all resulting documents for consistency. Args: results (Result): The search results from Redis. query (BaseQuery): The query object used for the search. storage_type (StorageType): The storage type of the search index (json or hash). Returns: List[Dict[str, Any]]: A list of processed document dictionaries. zAttempting to normalize inner product distance metric. Use cosine distance instead which is normalized inner product by definition.Ndocr%rOc|j}rd|vr|di}t|trt j|}t|t rd|di|Std|r8tt|j |j <| dd|S)Njsonidz%Unable to parse json data from Redis payload) __dict__get isinstancestrrSloadsdict ValueErrorfloat DISTANCE_IDpop)rQdoc_dict json_datanorm_fnrM unpack_jsons C:\Users\Dell Inspiron 16\Desktop\tws\AgrotaPowerBi\back-agrota-powerbi\mcp-client-agrota\venv\Lib\site-packages\redisvl/index/index.py_processz!process_results.._processs<  R6X-- VR00I)S)) 2 Jy11 )T** ?hll400>I>>PYPPQQ Q  *-hu'89::;;++HU& '  Y%%%c&g|] }|Srh).0rQres rd z#process_results..s! 2 2 2cHHSMM 2 2 2rf)rXr7totalindex storage_typerBJSONr8_return_fieldsr6_normalize_vector_distancerEfields_vector_field_nameattrsdistance_metricupperIPwarningswarnrCvaluerrYrdocs)rLrMrN dist_metricrerbrcs ` @@@rdprocess_resultsr||sB*%$$}  "k&6 6 % uk * * %$ $ 5/** 0P * M%2 3 9 I O O Q Q   .1 1 1 MV   "+"34jT#s(^. 3 2 2 2W\ 2 2 22rfr$rmc0dfd|jDS)aConvert an aggregate result object into a list of document dictionaries. This function processes results from Redis, handling different storage types and query types. For JSON storage with empty return fields, it unpacks the JSON object while retaining the document ID. The 'payload' field is also removed from all resulting documents for consistency. Args: results (AggregateResult): The aggregate results from Redis. query (AggregationQuery): The aggregation query object used for the aggregation. storage_type (StorageType): The storage type of the search index (json or hash). Returns: List[Dict[str, Any]]: A list of processed document dictionaries. cjtt|}|dd|S)N__score)rrr_)rowresults rdrez+process_aggregate_results.._processs0=--.. 9d### rfc&g|] }|Srhrh)rirres rdrjz-process_aggregate_results..s! . . .AHHQKK . . .rf)rows)rLrMrmres @rdprocess_aggregate_resultsrs0( / . . . . . ..rfceZdZUdZejeejeiZ e e d<dZ e defdZdefdZdeddfd Zdeddfd Ze defd Ze defd Ze deefd Ze defdZe defdZedefdZedeeeffdZ dZ!dedefdZ"defdZ#dS)BaseSearchIndexzBase search engine classrNcdSNrh)argskwargss rd__init__zBaseSearchIndex.__init__s rfrOcX|j|jjj|jS)z&The storage type for the index schema.) index_schema) _STORAGE_MAPrNrlrmselfs rd_storagezBaseSearchIndex._storages3At !2!?@    rfcltd|jjDS)z6Check if schema contains any SVS-VAMANA vector fields.c3@K|]}t|tVdSr)rXrD)rifields rd z3BaseSearchIndex._uses_svs_vamana..s=  27Jun - -      rf)anyrNrqvaluesrs rd_uses_svs_vamanaz BaseSearchIndex._uses_svs_vamanasA  ;?;;M;T;T;V;V      rfrMNct|trG|jj|j}|jr)|jjtj krtdt|ttfr{|jj j}|j}|ct|dkrRt|dkrAt|trdnd}t!jd|dt$d dSdSdSdSdS) zValidate a query.zPVector field using 'flat' algorithm does not support EF_RUNTIME query parameter.Nrr9r:agQuery-time stopwords are configured but the index has STOPWORDS 0 (stopwords = []). This is counterproductive: all words including common words like 'of', 'the', 'a' are indexed, but your query-time stopwords will filter them from the search query. This makes your search less precise than it could be. Consider setting stopwords=None (or any falsy value) in z! to search for all indexed words.) stacklevel)rXrrNrqrr ef_runtimers algorithmrFHNSWr-r9r:rl stopwordslenrwrx UserWarning)rrMrindex_stopwordsquery_stopwords query_types rd_validate_queryzBaseSearchIndex._validate_querys? e[ ) ) K&u'?@E EK$9=Q=V$V$V*f ei)=> ? ? "k/9O#oO  +((A--((1,,"%330KK/  }PZ }}}   #  ,+--,,rfc ddlm}ddlm}n)#tt f$rt t wxYwt||stdt|dS)z-Validate that a hybrid query can be executed.r) HybridResultrz'query must be of type HybridQuery, got N) #redis.commands.search.hybrid_resultrredisvl.query.hybridr ImportErrorModuleNotFoundError_HYBRID_SEARCH_ERROR_MESSAGErX TypeErrortype)rrMrrs rd_validate_hybrid_queryz&BaseSearchIndex._validate_hybrid_querys < H H H H H H 8 8 8 8 8 8 801 < < <:;; ; <%-- USd5kkSSTT T U Us &5c$|jjjS)z#The name of the Redis search index.)rNrlrIrs rdrIzBaseSearchIndex.name*s{ %%rfcb|jjj}t|tr|dn|S)zpThe key prefix used in forming Redis keys. For multi-prefix indexes, returns the first prefix. rrNrlprefixrXlistrrs rdrzBaseSearchIndex.prefix/s. ")&vt44@vayy&@rfcX|jjj}t|tr|n|gS)z+All key prefixes configured for this index.rrs rdprefixeszBaseSearchIndex.prefixes8s,")#FD11?vvx?rfc$|jjjS)z]The optional separator between a defined prefix and key value in forming a Redis key.)rNrl key_separatorrs rdrzBaseSearchIndex.key_separator>s{ ..rfc$|jjjS)zNThe underlying storage type for the search index; either hash or json.)rNrlrmrs rdrmzBaseSearchIndex.storage_typeDs{ --rf schema_pathc >tj|}|dd|i|S)aCreate a SearchIndex from a YAML schema file. Args: schema_path (str): Path to the YAML schema file. Returns: SearchIndex: A RedisVL SearchIndex object. .. code-block:: python from redisvl.index import SearchIndex index = SearchIndex.from_yaml("schemas/schema.yaml", redis_url="redis://localhost:6379") rNrh)rA from_yaml)clsrrrNs rdrzBaseSearchIndex.from_yamlJs/ &{33s++&+F+++rf schema_dictc >tj|}|dd|i|S)aCreate a SearchIndex from a dictionary. Args: schema_dict (Dict[str, Any]): A dictionary containing the schema. Returns: SearchIndex: A RedisVL SearchIndex object. .. code-block:: python from redisvl.index import SearchIndex index = SearchIndex.from_dict({ "index": { "name": "my-index", "prefix": "rvl", "storage_type": "hash", }, "fields": [ {"name": "doc-id", "type": "tag"} ] }, redis_url="redis://localhost:6379") rNrh)rA from_dict)rrrrNs rdrzBaseSearchIndex.from_dict]s/4&{33s++&+F+++rfc td)#Disconnect from the Redis database.z0This method should be implemented by subclasses.)NotImplementedErrorrs rd disconnectzBaseSearchIndex.disconnectzs!"TUUUrfrTcd|j||j|jjjS)aConstruct a redis key as a combination of an index key prefix (optional) and specified id. The id is typically either a unique identifier, or derived from some domain-specific metadata combination (like a document id or chunk id). Args: id (str): The specified unique identifier for a particular document indexed in Redis. Returns: str: The full Redis key including key prefix and value as a string. )rTrr)r_keyrrNrlr)rrTs rdkeyzBaseSearchIndex.key~s6}!!;++9"   rfcjt|jd|jd|jd|jjdS)Nz(name=z , prefixes=z, storage_type=))r__name__rIrrmryrs rd__repr__zBaseSearchIndex.__repr__sQDzz" 9 9$) 9 9$- 9 9 -3 9 9 9 rf)$r __module__ __qualname____doc__rBHASHr3rnr4rrA__annotations__rpropertyr2rboolrr'rrrrYrIrr rrrm classmethodrrrrrrrhrfrdrrsU"" ++L     +   X  $    #Y#4####J UC UD U U U U&c&&&X&AAAAXA@$s)@@@X@ /s///X/ .k...X. ,C,,,[,$,DcN,,,[,8VVV c c    * #      rfrcbeZdZdZedd dFdedeedeed ee ee fd e f d Z d Z e dGd edeedeefdZedeefdZedefdZedddHdeefdZedddefdZdIdZdJde de ddfdZdKde fdZdeedefdZdefdZd eeeefdefd!Zd"eeeefdefd#Zd eeeefd$edeeeeffd%Z dLd&e!e d'eed ee!ed$eed(ee"d)eedeefd*Z#d+edee ee ffd,Z$d-e%dee ee ffd.Z&d/e'dee ee ffd0Z(dMd2Z) dNd4ee*d)eded5fd6Z+dOd7Z,d8e-dee ee ffd9Z. dNd4e/e0d)edeee ee ffd:Z1d8e0dee ee ffd;Z2d8ee0e%e-e'fdee ee ffd<Z3dPd8e0d>ede4fd?Z5deefd@Z6de fdAZ7e8d edede ee ffdBZ9dHd eede ee ffdCZ:dDZ;dEZ> &{33s6<226222rfrOc|jSz&The underlying redis-py client object.)rrs rdclientzSearchIndex.clients ""rfc@|j]|j5|j7i|j}|jr |j|d<t jdd|ji||_dddn #1swxYwY|js-|jr&t j|j|jd|_|jS)zs Get a Redis client instance. Lazily creates a Redis client instance if it doesn't exist. NrrTrh) rrrrr<rrrrrrs rd _redis_clientzSearchIndex._redis_clients    &  &.8 78F~<-1^z**@*U++"&/+ ++D'               % *$. * " 6#   &*D """s?AA!Aconnect'Pass connection parameters in __init__.c 6tjdd|i||_dS)aConnect to a Redis instance using the provided `redis_url`, falling back to the `REDIS_URL` environment variable (if available). Note: Additional keyword arguments (`**kwargs`) can be used to provide extra options specific to the Redis connection. Args: redis_url (Optional[str], optional): The URL of the Redis server to connect to. Raises: redis.exceptions.ConnectionError: If the connection to the Redis server fails. ValueError: If the Redis URL is not provided nor accessible through the `REDIS_URL` environment variable. ModuleNotFoundError: If required Redis modules are not installed. rNrh)r<rr)rrrs rdrzSearchIndex.connect7s4&5I   #)  rf set_clientc <tj|||_|S)aManually set the Redis client to use with the search index. This method configures the search index to use a specific Redis or Async Redis client. It is useful for cases where an external, custom-configured client is preferred instead of creating a new one. Args: redis_client (Redis): A Redis or Async Redis client instance to be used for the connection. Raises: TypeError: If the provided client is not valid. )r<rr)rrrs rdrzSearchIndex.set_clientNs" 2<@@@* rfc`t|jstjtdSzValidate SVS-VAMANA support. Raises: RedisModuleVersionError: If SVS-VAMANA requirements are not met. N)r>rr.for_svs_vamanar@rs rd_check_svs_supportzSearchIndex._check_svs_supportas6 D.// P)89NOO O P Prf overwritedropc P|jj}|stdt|tst d|r||rN|st ddSt d| | |jj j }t|tr|n|g}t||jj}|jj j}t|jt(r t+|j|j|||dS|j|j||| dS#t2jj$r-}t9d |jd t;||d}~wt<$rG}td t9d |jdt;||d}~wwxYw)aCreate an index in Redis with the current schema and properties. Args: overwrite (bool, optional): Whether to overwrite the index if it already exists. Defaults to False. drop (bool, optional): Whether to drop all keys associated with the index in the case of overwriting. Defaults to False. Raises: RuntimeError: If the index already exists and 'overwrite' is False. ValueError: If no fields are defined for the index. .. code-block:: python # create an index in Redis; only if one does not exist with given name index.create() # overwrite an index in Redis without dropping associated data index.create(overwrite=True) # overwrite an index in Redis; drop associated data (clean slate) index.create(overwrite=True, drop=True) No fields defined for indexoverwrite must be of type bool&Index already exists, not overwriting.N"Index already exists, overwriting.)r r index_type index_namerrq definitionrrqrrFailed to create index ' ' on Redis: &Error while trying to create the index!Unexpected error creating index '': ) rN redis_fieldsr\rXrrrrexistsrrdeleterlrrr,rrrrrrrIft create_indexredis exceptions RedisErrorr/rY Exception exception) rrr rr prefix_listrres rdcreatezSearchIndex.createjsa2{/  <:;; ;)T** ><== =  " " &  # # % % % ;;== #  DEEEt KK< = = = KKTK " " " [&-F$.vt$<$<J&&6(K("t}/AJ )3I$,l;; $#y-')' "%%di00==')'> *   "J49JJ#a&&JJ       E F F F"JDIJJ#a&&JJ  s, BF5FH%)(G H%AH  H%Tc |rBt|jtr(|d|jjjg}n*d|jjjg}|r|dt|jtr.|jg}|jj |d|idS|jj |dS#t$r%}tdt||d}~wwxYw)aCDelete the search index while optionally dropping all keys associated with the index. Args: drop (bool, optional): Delete the key / documents pairs in the index. Defaults to True. raises: redis.exceptions.ResponseError: If the index does not exist. FT.DROPINDEXDD target_nodesError while deleting index: N) rXrrclearrNrlrIappendget_default_nodeexecute_commandr"r/rY)rr cmd_argsr*r%s rdrzSearchIndex.deletes S * 4#5|DD * *DK,=,BC+DK,=,BC*OOD)))$,l;; > $ 2 C C E EF 2"2HX<XXXXX2"2H==== S S S"#J#a&&#J#JKKQR R SsB4C 8C C8 C33C8 batch_keysctt|j}t|t}|rud}|D]o} |tt ||z }/#tjj $r*}t d|d|Yd}~hd}~wwxYwntt |j|}|S)Delete a batch of keys from Redis. For Redis Cluster, keys are deleted individually due to potential cross-slot limitations. For standalone Redis, keys are deleted in a single operation for better performance. Args: batch_keys (List[str]): List of Redis keys to delete. Returns: int: Count of records deleted from Redis. rFailed to delete key : N) rrrrXrintrrr r!rwarningrr1r is_clusterrecords_deleted_in_batch key_to_deleter%s rd _delete_batchzSearchIndex._delete_batchsot'9:: 55  M'( $!+ Q Q Q,S&-- :V:V0W0WW,,'2QQQNN#O=#O#OA#O#OPPPPPPPPQ Q (,C 1K'L'L $''s+A%%B#9 BB#c^d}d}|}t|d|z}d}ttddg}|d| ||}|r+||kr%d |D}|||z }nnD|S) aClear all keys in Redis associated with the index, leaving the index available and in-place for future insertions or updates. NOTE: This method requires custom behavior for Redis Cluster because here, we can't easily give control of the keys we're clearing to the user so they can separate them based on hash tag. Returns: int: Count of records deleted from Redis. )\(?num_docsr*rT return_fieldsTcg|] }|d SrTrhrirecords rdrjz%SearchIndex.clear.. ???vfTl???rfrrr8r;paging_queryr< r batch_size max_ratiormax_records_deletedtotal_records_deletedrMbatchr1s rdr,zSearchIndex.clears  yy{{"  y (  &',S11$HHH Q ### KK&&E .2EEE????? %););J)G)GG%%  %$rfkeysc~t|tr|jj|S|j|S)Remove a specific entry or entries from the index by it's key ID. Args: keys (Union[str, List[str]]): The document ID or IDs to remove from the index. Returns: int: Count of records deleted from Redis. )rXr rr)rrRs rd drop_keyszSearchIndex.drop_keyss@ dD ! ! 3,4%,d3 3%,,T22 2rfidsc>t|trY|sdSfd|D}tjtrt |st djj|S|}j|S)4Remove documents from the index by their document IDs. This method converts document IDs to Redis keys automatically by applying the index's key prefix and separator configuration. NOTE: Cluster users will need to incorporate hash tags into their document IDs and only call this method with documents from a single hash tag at a time. Args: ids (Union[str, List[str]]): The document ID or IDs to remove from the index. Returns: int: Count of documents deleted from Redis. rc:g|]}|SrhrrirTrs rdrjz.SearchIndex.drop_documents..2#///RDHHRLL///rf8All keys must share a hash tag when using Redis Cluster.)rXrrrrr\rr)rrVrRrs` rddrop_documentszSearchIndex.drop_documentss c4  2 q////3///D"L *400 !N-4%,d3 3((3--C%,,S11 1rfttlct|trH|j}|D]}||||S|j||S)Set the expiration time for a specific entry or entries in Redis. Args: keys (Union[str, List[str]]): The entry ID or IDs to set the expiration for. ttl (int): The time-to-live in seconds. )rXrrpipelineexpireexecute)rrRr_pipers rd expire_keyszSearchIndex.expire_keys?sw dD ! ! 8%..00D & & C%%%%<<>> !%,,T377 7rfdataid_field preprocessrMc D |j|j|||||||jS#t$r }t dd}~wt$r?}t dtdt||d}~wwxYw)arLoad objects to the Redis database. Returns the list of keys loaded to Redis. RedisVL automatically handles constructing the object keys, batching, optional preprocessing steps, and setting optional expiration (TTL policies) on keys. Args: data (Iterable[Any]): An iterable of objects to store. id_field (Optional[str], optional): Specified field used as the id portion of the redis key (after the prefix) for each object. Defaults to None. keys (Optional[Iterable[str]], optional): Optional iterable of keys. Must match the length of objects if provided. Defaults to None. ttl (Optional[int], optional): Time-to-live in seconds for each key. Defaults to None. preprocess (Optional[Callable], optional): A function to preprocess objects before storage. Defaults to None. batch_size (Optional[int], optional): Number of objects to write in a single Redis pipeline execution. Defaults to class's default batch size. Returns: List[str]: List of keys loaded to Redis. Raises: SchemaValidationError: If validation fails when validate_on_load is enabled. RedisVLError: If there's an error loading data to Redis. objectsrhrRr_rirMvalidate,Data validation failed during load operationN!Error while loading data to RedisFailed to load data: ) rwriterrr1rerrorr"r#r0rY)rrgrhrRr_rirMr%s rdloadzSearchIndex.loadPsL H=&&"!%%/'   %    LLG H H H  H H H   @ A A A?s1vv??@@a G Hs +. BA B :BBrTc|j|j||g}|rt |dSdS)aFetch an object from Redis by id. The id is typically either a unique identifier, or derived from some domain-specific metadata combination (like a document id or chunk id). Args: id (str): The specified unique identifier for a particular document indexed in Redis. Returns: Dict[str, Any]: The fetched object. rN)rrWrrr)rrTobjs rdfetchzSearchIndex.fetchsIm 2TXXb\\NCC  ) Q(( (trfaggregation_queryc||||j}t|||jjjS)7Execute an aggregation query and processes the results. query_paramsrMrm aggregateparamsrrNrlrmrrwrLs rd _aggregatezSearchIndex._aggregatesM.. *1!  ) #*7    rf sql_queryc& ddlm}ddlm}n#t$rt dwxYw||j}|||j|}||j|j }d|j DS)a*Execute a SQL query and return results. Args: sql_query: The SQLQuery object containing the SQL statement. Returns: List of dictionaries containing the query results. Raises: ImportError: If sql-redis package is not installed. r)Executor)SchemaRegistry\sql-redis is required for SQL query support. Install it with: pip install redisvl[sql-redis]rc,g|]}t|Srhrrirs rdrjz*SearchIndex._sql_query.. :::s c"":::rf) sql_redis.executorrsql_redis.schemarrrload_allrdsqlrr)rrrrregistryexecutorrs rd _sql_queryzSearchIndex._sql_querys  3 3 3 3 3 3 7 7 7 7 7 7 7   B   ">$"4558D.99!!)- 8H!II::fk::::s )r$c~ |j|jjjj|i|S#t jj$rE}dt|vrtdtdt||d}~wt$r%}tdt||d}~wwxYw)7Perform an aggregation operation against the index. Wrapper around the aggregation API that adds the index name to the query and passes along the rest of the arguments to the redis-py ft().aggregate() method. Returns: Result: Raw Redis aggregation results. CROSSSLOTNCross-slot error during aggregation. Ensure consistent hash tags in your keys.Error while aggregating: N$Unexpected error while aggregating: ) rrrNrlrIr~rr r!rYr/r"rrrr%s rdr~zSearchIndex.aggregates J4%(():)?@@J * P P Pc!ff$$&d##Gs1vv#G#GHHa O   "?s1vv??  s"36B< AB  B< B77B< queriesr&cg}|j|jjj}i}t |jdvr d|t <tdt||D]Q}||||z}|j d5}g} |D]~} t| tr'| | d| d\} } n| | d\} } | | |jd g| Ri|tj} |}tj| z d z}t#|D]:\}}| |}|||| }| |; dddn #1swxYwYS|S) aPerform a search against the index for multiple queries. This method takes a list of queries and optionally query params and returns a list of Result objects for each query. Results are returned in the same order as the queries. NOTE: Cluster users may need to incorporate hash tags into their query to avoid cross-slot operations. Args: queries (List[SearchParams]): The queries to search for. batch_size (int, optional): The number of queries to search for at a time. Defaults to 10. Returns: List[Result]: The search results for each query. 3rTrF transactionrzN FT.SEARCH@@rMduration)rrrNrlrIr*r)rangerrbrXtuple_mk_query_argsr-r/timerd enumerate _parse_search)rrrM all_resultsrHoptionsi batch_queriesrebatch_built_queriesrM query_argsqstrLrj query_results _built_query parsed_results rd batch_searchzSearchIndex.batch_searchsZ( #&&t{'8'=>>  2 3 38 C C$(GL !q#g,, 33' 6' 6A#AJ$67M #,,,??! 64&(#*E!%//(.(=(=!!H58)>)) AA)/(=(=!)>)) A(..q111(D(##" Y[[,,..!IKK",6(1'(:(:66$A}#6q#9L$*$8$8%*!)%9%%M  &&}555563! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6DsDF22F6 9F6 c  t|jtr7t|j|jjjg|Ri|S|j|jjjj|i|S#tj j $rE}dt|vrtdtdt||d}~wt$r%}tdt||d}~wwxYw)aPerform a search against the index. Wrapper around the search API that adds the index name to the query and passes along the rest of the arguments to the redis-py ft().search() method. Returns: Result: Raw Redis search results. rICross-slot error during search. Ensure consistent hash tags in your keys.Error while searching: N"Unexpected error while searching: )rXrrrrrNrlrIrHrr r!rYr/r"rs rdrHzSearchIndex.search%sP Y$,l;; %&))$+*;*@AA Lt),,T[->-CDDK#* N N Nc!ff$$&_##ESVV#E#EFFA M Y Y Y"#PA#P#PQQWX X Ys+AB3BD AC D ( DD rMc j|j|jjj}||t |dstt|j d|j |j |j r|j nd|jd|}d|jDS)aPerform a hybrid search against the index, combining text and vector search. Args: query (HybridQuery): The text+vector search query to be performed, with configurable fusion methods and post-processing. kwargs: Additional arguments to pass to the redis-py hybrid_search method (e.g. timeout). Returns: List[Dict[str, Any]]: The search results ordered by combined score unless otherwise specified. Notes: Hybrid search is only available in Redis 8.4.0+, and requires redis-py >= 7.1.0. See Also: - `FT.HYBRID command documentation `_ - `redis-py hybrid_search documentation `_ .. code-block:: python from redisvl.query import HybridQuery hybrid_query = HybridQuery( text="lorem ipsum dolor sit amet", text_field_name="description", vector=[0.1, 0.2, 0.3], vector_field_name="embedding" ) results = index.query(hybrid_query) hybrid_searchNrMcombine_methodpost_processingparams_substitutionc,g|]}t|Srhrrirs rdrjz.SearchIndex._hybrid_search..u :::Q a  :::rfrh)rrrNrlrIrhasattrrrrrMcombination_methodpostprocessing_config build_argsrrL)rrMrrlrLs rd_hybrid_searchzSearchIndex._hybrid_searchDs@"%%dk&7&<== ##E***uo.. <:;; ;%%%  + 3.99;;++ %       ;:'/::::rfc|d|D|}g}t||D]1\}}t|||j}||2|S)z/Execute a batch of queries and process results.c*g|]}|j|jfSrhrMrrirMs rdrjz+SearchIndex.batch_query..|! > > >Uek5< ( > > >rfrMrMrNrzipr|rNr-rrrMrL all_parsedrM batch_resultsparseds rd batch_queryzSearchIndex.batch_queryws## > >g > > >:$   $'$9$9 & & E=$]% TTTF   f % % % %rfc ||n2#t$r%}tdt||d}~wwxYw||j|j}t |||jS)z$Execute a query and process results.Invalid query: Nrzrrr-rYrHrMrr|rNrrMr%rLs rdrKzSearchIndex._querys J   ' ' ' '# J J J&'AQ'A'ABB I J++ek +EEweDKHHHHs A AAc(t|tr||St|tr||St|t r||S||S)aExecute a query on the index. This method takes a BaseQuery, AggregationQuery, or HybridQuery object directly, and handles post-processing of the search. Args: query (Union[BaseQuery, AggregationQuery, HybridQuery]): The query to run. Returns: List[Result]: A list of search results. .. code-block:: python from redisvl.query import VectorQuery query = VectorQuery( vector=[0.16, -0.34, 0.98, 0.23], vector_field_name="embedding", num_results=3 ) results = index.query(query) rXr5rrrrrrKrrMs rdrMzSearchIndex.querys6 e- . . &??5)) ) x ( ( &??5)) ) { + + &&&u-- -;;u%% %rf page_sizec#Kt|tstd|dkrtdd} |||||}|sdS|V||z }9)aExecute a given query against the index and return results in paginated batches. This method accepts a RedisVL query instance, enabling pagination of results which allows for subsequent processing over each batch with a generator. Args: query (BaseQuery): The search query to be executed. page_size (int, optional): The number of results to return in each batch. Defaults to 30. Yields: A generator yielding batches of search results. Raises: TypeError: If the page_size argument is not of type int. ValueError: If the page_size argument is less than or equal to zero. .. code-block:: python # Iterate over paginated search results in batches of 10 for result_batch in index.paginate(query, page_size=10): # Process each batch of results pass Note: The page_size parameter controls the number of items each result batch contains. Adjust this value based on performance considerations and the expected volume of search results. Note: For stable pagination, the query must have a `sort_by` clause. zpage_size must be an integerr page_size must be greater than 0TNrXr6rr\rJrK)rrMroffsetrLs rdpaginatezSearchIndex.paginatesH)S)) <:;; ; >>?@@ @ LL + + +kk%((G MMM i F rfcPt|jdS)List all search indices in Redis database. Returns: List[str]: The list of indices in the database. FT._LIST)rrr/rs rdlistallzSearchIndex.listalls# T/?? KKLLLrfcL|jjj|vS){Check if the index exists in Redis. Returns: bool: True if the index exists, False otherwise. rNrlrIrrs rdrzSearchIndex.existss { %77rfc | t|tr<|}|d||}t |}n'||}t|S#t$r(}td|dt||d}~wwxYw)z1Run FT.INFO to fetch information about the index.FT.INFOr*Error while fetching index info: N) rXr get_random_noder/rrrrr"r/rYrIrnoderrr%s rdrzSearchIndex._infos ,(899 4#3355%55t$6!((#t,,1133 && &   "CCC3q66CC  sBB B;#B66B;c^|p|jjj}|||jS)Get information about the index. Args: name (str, optional): Index name to fetch info about. Defaults to None. Returns: dict: A dictionary containing the information about the index. )rNrlrIrr)rrIrs rdrzSearchIndex.info s-3T[.3 zz*d&8999rfc|Srrhrs rd __enter__zSearchIndex.__enter__s rfc.|dSrrrexc_typeexc_valexc_tbs rd__exit__zSearchIndex.__exit__s rf)NNNFNNrrONFFT)NNNNNrOr$rrOr&r)=rrrrr!rAr rrYrrrrrrrrrrr"rrrr&rr r6r<r,rrUr^rfr rrsrvr5rrrr~ SearchParamsrrHrrr r'rrKrMr rrr staticmethodrrrrrhrfrdrrs8*,LMM37#'6:!& +4+4+4/+4C= +4 $DcN3 +4  +4+4+4NM+4Z###37#' &3&3&3/&3C= &3&3&3[&3P#1###X#####X#4$MNN  #   ON ,'PQQRQ$PPPPJJJDJTJJJJXSS4SSSSB(S (c((((4%s%%%%@ 3eCcN3 3 3 3 3 32%T#Y"72C2222@8#tCy.)8038 sDI~ 8888(#'(,!)-$(8H8Hsm8H3-8Hx}% 8H c] 8H X& 8HSM8H c8H8H8H8Htc3h 8&  ,<  d3PS8nAU     ;H;d38n1E;;;;>4>@BBL)B7:B hBBBBHYYYY>1;K1;d4S>>R1;1;1;1;h?A *8; d4S>" # III$tCH~*>IIII"&9&6 XMN"& d38n "&"&"&"&H2 2 i2 C2 2 2 2 2 hMcMMMM88888C4S>\" : :# :$sCx. : : : :rfrceZdZdZeddddddddedeed eed ee ee fd e f d Z e dKd ed eedeefdZedeefdZedddLdeefdZeddd eeeffdZdefdZd eeefdefdZed ed ede ee ffdZdMdZdNde de ddfdZdOde fdZdeedefd Zdefd!Z d"eeeefdefd#Z!d$eeeefdefd%Z"d"eeeefd&edeeeeffd'Z#ed(d) dPd*e$e d+eed"ee$ed&eed,ee%d(eed-eedeefd.Z&d/edee ee ffd0Z'd1e(dee ee ffd2Z)dQd4Z* dRd6ee+d-eded7fd8Z,dSd9Z-d:e.dee ee ffd;Z/ dRd6ee0d-edeee ee ffd<Z1d:e0dee ee ffd=Z2d>e3dee ee ffd?Z4d:ee0e(e.e3fdee ee ffd@Z5dTd:e0dBede6fdCZ7deefdDZ8de fdEZ9dLd eede ee ffdFZ:dGZ;dHZdS)UAsyncSearchIndexaFA search index class for interacting with Redis as a vector database in async-mode. The AsyncSearchIndex is instantiated with a reference to a Redis database and an IndexSchema (YAML path or dictionary object) that describes the various settings and field configurations. .. code-block:: python from redisvl.index import AsyncSearchIndex # initialize the index object with schema from file index = AsyncSearchIndex.from_yaml( "schemas/schema.yaml", redis_url="redis://localhost:6379", validate_on_load=True ) # create the index await index.create(overwrite=True, drop=False) # data is an iterable of dictionaries await index.load(data) # delete index and data await index.delete(drop=True) redis_kwargsrNF)rrrrrNrrrrc d|vr|d}t|tstd||_||_|dd|_||_||_|pi|_ tj |_ |dd|_ |du|_|jr)tj|t#|jdSdS)aBInitialize the RedisVL async search index with a schema. Args: schema (IndexSchema): Index schema object. redis_url (Optional[str], optional): The URL of the Redis server to connect to. redis_client (Optional[AsyncRedis]): An instantiated redis client. connection_kwargs (Optional[Dict[str, Any]]): Redis client connection args. validate_on_load (bool, optional): Whether to validate data against schema when loading. Defaults to False. r rrNrF)r_rXrAr\rNrrrrrasynciorrrrrrr#r)rrNrrrrrs rdrzAsyncSearchIndex.__init__<s0 V # # & > : : &+.. HFGG G !1(. :t(D(D*#"3"9r\^^ !',?!G!G".$"6  " B  T<#@#@ A A A A A B BrfrIc\K|s|std|rtjdd|i|d{V}n!|rtj|d{Vd|d<|td|||d{V}t |}t j|}||fd|i|S) aW Initialize from an existing search index in Redis by index name. Args: name (str): Name of the search index in Redis. redis_client(Optional[Redis]): An instantiated redis client. redis_url (Optional[str]): The URL of the Redis server to connect to. zJMust provide either a redis_url or redis_client to fetch Redis index info.rNTrzXFailed to obtain a valid Redis client. Please provide a valid redis_client or redis_url.rrh)r\r<_get_aredis_connectionvalidate_async_redisrr=rArrs rdrzAsyncSearchIndex.from_existingjs4$  \   /!7!N""#"""LL /(=lKK K K K K K K K*.F& '  D  99T<88888888 2:>> &{33s6?? ????rfrOc|jSr)rrs rdrzAsyncSearchIndex.clients !!rfrrcKtjdttjdd|i|d{V}||d{VdS)zP[DEPRECATED] Connect to a Redis instance. Use connection parameters in __init__.z?connect() is deprecated; pass connection parameters in __init__rNrh)rwrxDeprecationWarningr<rr)rrrrs rdrzAsyncSearchIndex.connects  M    .D   #)        oof%%%%%%%%%%%rfrcK||d{V}|d{V|j4d{V||_dddd{Vn#1d{VswxYwY|S)z [DEPRECATED] Manually set the Redis client to use with the search index. This method is deprecated; please provide connection parameters in __init__. N)_validate_clientrrr)rrs rdrzAsyncSearchIndex.set_clients "22<@@@@@@@@ oo: . . . . . . . .!-D  . . . . . . . . . . . . . . . . . . . . . . . . . . . sA A),A)cK|j|j4d{V|jGi|j}|jr |j|d<|jr |j|d<t jdi|d{V|_ dddd{Vn#1d{VswxYwY|js3|jr,t j|j|jd{Vd|_|jS)z5Lazily instantiate and return the async Redis client.NrrTrh) rrrrrr<rrrrs rd _get_clientzAsyncSearchIndex._get_clients   %z        %-8 78F>.2o{+~<-1^z*4KUUfUUUUUUUU&                           % *$. *(="       &*D "!!sAA99 BBcKt|ttfr0tjdt t j|}|St|ttfstd|S)NzPassing a sync Redis client to AsyncSearchIndex is deprecated and will be removed in the next major version. Please use an async Redis client instead.zBInvalid async client type: must be AsyncRedis or AsyncRedisCluster) rXrrrwrxrr<sync_to_async_redis AsyncRedisAsyncRedisClusterr\)rrasync_redis_clients rdrz!AsyncSearchIndex._validate_clients lUL$9 : :  M.#    ':<HH & %L:7H*IJJ T rfc K t|trB|}|d||d{V}t |}n-||d{V}t|S#t$r(}td|dt||d}~wwxYw)Nrrrr) rXrrr/rrrrr"r/rYrs rdrzAsyncSearchIndex._infos  ,(9:: :#3355+;;t$ <  !(()__T227799999999 && &   "CCC3q66CC  sBB C !#CC cK|d{V}t|d{VstjtdSr)rr?r.rr@)rrs rd_check_svs_support_asyncz)AsyncSearchIndex._check_svs_support_asyncsl ''))))))))'//////// P)89NOO O P Prfrr c K|d{V}|jj}|stdt |t st d|r|d{V| d{VrS|st ddSt d| |d{V |jj j}t |tr|n|g}t!||jj}|jj j}t |t(r+t+|jj j||||d{VdS||jj j|||d{VdS#t2jj$r-} t9d |jd t;| | d} ~ wt<$rG} td t9d |jd t;| | d} ~ wwxYw)aAsynchronously create an index in Redis with the current schema and properties. Args: overwrite (bool, optional): Whether to overwrite the index if it already exists. Defaults to False. drop (bool, optional): Whether to drop all keys associated with the index in the case of overwriting. Defaults to False. Raises: RuntimeError: If the index already exists and 'overwrite' is False. ValueError: If no fields are defined for the index. .. code-block:: python # create an index in Redis; only if one does not exist with given name await index.create() # overwrite an index in Redis without dropping associated data await index.create(overwrite=True) # overwrite an index in Redis; drop associated data (clean slate) await index.create(overwrite=True, drop=True) Nr r r rrrrrrrrr) rrNrr\rXrrrr!rrrrrlrrr,rrrrrrIrrrr r!r/rYr"r#) rrr rrrr$rrr%s rdr&zAsyncSearchIndex.creates2'')))))))){/  <:;; ;)T** ><== =  " " 2//11 1 1 1 1 1 1 1       $  DEEEt KK< = = =++d## # # # # # # # [&-F$.vt$<$<J&&6(K("t}/AJ )3I&"344 0#{05!')' ii 1 677DD')'E *   "J49JJ#a&&JJ       E F F F"JDIJJ#a&&JJ  s-:BGAGI#'(H I#AII#Tc K|d{V} |rCt|tr.|d{Vd|jjjg}n*d|jjjg}|r|dt|tr*|g}|j |d|id{VdS|j |d{VdS#t$r%}tdt||d}~wwxYw)zDelete the search index. Args: drop (bool, optional): Delete the documents in the index. Defaults to True. Raises: redis.exceptions.ResponseError: If the index does not exist. Nr(r)r*r+) rrXrr,rNrlrIr-r.r/r"r/rY)rr rr0r*r%s rdrzAsyncSearchIndex.deleteNsq'')))))))) S * 6+<== *jjll"""""""*DK,=,BC+DK,=,BC*OOD)))&"344 8 & 7 7 9 9: ,f,hR\RRRRRRRRRRR,f,h7777777777 S S S"#J#a&&#J#JKKQR R SsB,C C D ( DD r1cK|d{V}t|t}|r{d}|D]u} |tt||d{Vz }5#t jj$r*}t d|d|Yd}~nd}~wwxYwn|j|d{V}|S)r3Nrr4r5) rrXrrr6rrr r!rr7r8s rdr<zAsyncSearchIndex._delete_batchos*''))))))))(9::  H'( $!+ Q Q Q,6==#?#???????11,,'2QQQNN#O=#O#OA#O#OPPPPPPPPQ  Q.;V]J-G'G'G'G'G'G'G $''s1A--B+ B&&B+cKd}d}|d{V}t|d|z}d}ttddg}|d| ||d{V}|r1||kr+d |D}|||d{Vz }nnP|S) aClear all keys in Redis associated with the index, leaving the index available and in-place for future insertions or updates. NOTE: This method requires custom behavior for Redis Cluster because here, we can't easily give control of the keys we're clearing to the user so they can separate them based on hash tag. Returns: int: Count of records deleted from Redis. r>r?Nr@rrArTrBTcg|] }|d SrErhrFs rdrjz*AsyncSearchIndex.clear..rHrfrIrLs rdr,zAsyncSearchIndex.clears  YY[[      "  y (  &',S11$HHH Q ### ++e,,,,,,,,E .2EEE????? %t/A/A*/M/M)M)M)M)M)M)MM%%  %$rfrRcK|d{V}t|tr|j|d{VS||d{VS)rTN)rrXrr)rrRrs rdrUzAsyncSearchIndex.drop_keyss'')))))))) dD ! ! -&------- -t,,,,,,,, ,rfrVcpKd{V}t|trU|sdSfd|D}t|trt |st d|j|d{VS|}||d{VS)rXNrc:g|]}|SrhrZr[s rdrjz3AsyncSearchIndex.drop_documents..r\rfr])rrXrrrr\rr)rrVrrRrs` rdr^zAsyncSearchIndex.drop_documentss '')))))))) c4 , q////3///D&"344 =QRV=W=W  N'------- -((3--Cs++++++++ +rfr_c.K|d{V}t|trI|}|D]}||||d{VS|||d{VS)raN)rrXrrbrcrd)rrRr_rrers rdrfzAsyncSearchIndex.expire_keyss'')))))))) dD ! ! 2??$$D & & C%%%%'''''' 'tS11111111 1rf concurrencyzUse batch_size instead.rgrhrirMc ~K|d{V} |j||||||||jd{VS#t$r } t dd} ~ wt$r?} t dtdt| | d} ~ wwxYw)aAsynchronously load objects to Redis. Returns the list of keys loaded to Redis. RedisVL automatically handles constructing the object keys, batching, optional preprocessing steps, and setting optional expiration (TTL policies) on keys. Args: data (Iterable[Any]): An iterable of objects to store. id_field (Optional[str], optional): Specified field used as the id portion of the redis key (after the prefix) for each object. Defaults to None. keys (Optional[Iterable[str]], optional): Optional iterable of keys. Must match the length of objects if provided. Defaults to None. ttl (Optional[int], optional): Time-to-live in seconds for each key. Defaults to None. preprocess (Optional[Callable], optional): A function to preprocess objects before storage. Defaults to None. batch_size (Optional[int], optional): Number of objects to write in a single Redis pipeline execution. Defaults to class's default batch size. Returns: List[str]: List of keys loaded to Redis. Raises: SchemaValidationError: If validation fails when validate_on_load is enabled. RedisVLError: If there's an error loading data to Redis. .. code-block:: python data = [{"test": "foo"}, {"test": "bar"}] # simple case keys = await index.load(data) # set 360 second ttl policy on data keys = await index.load(data, ttl=360) # load data with predefined keys keys = await index.load(data, keys=["rvl:foo", "rvl:bar"]) # load data with preprocessing step def add_field(d): d["new_field"] = 123 return d keys = await index.load(data, preprocess=add_field) Nrkrnrorp) rrawriterr1rrrr"r#r0rY) rrgrhrRr_rir+rMrr%s rdrszAsyncSearchIndex.loadsx'')))))))) H--!%%/.         %    LLG H H H  H H H   @ A A A?s1vv??@@a G Hs#,A B<A00 B<=:B77B<rTcK|d{V}|j|||gd{V}|rt |dSdS)aAsynchronously etch an object from Redis by id. The id is typically either a unique identifier, or derived from some domain-specific metadata combination (like a document id or chunk id). Args: id (str): The specified unique identifier for a particular document indexed in Redis. Returns: Dict[str, Any]: The fetched object. Nr)rragetrr)rrTrrus rdrvzAsyncSearchIndex.fetch<s''))))))))M&&v ~>>>>>>>>  ) Q(( (trfrwcK|||jd{V}t|||jjjS)ryrzNr|r}rs rdrzAsyncSearchIndex._aggregateNsq *1'        ) #*7    rfr$cK|d{V} ||jjjj|i|d{VS#t jj$rE}dt|vrtdtdt||d}~wt$r%}tdt||d}~wwxYw)rNrrrr) rrrNrlrIr~rr r!rYr/r"rrrrr%s rdr~zAsyncSearchIndex.aggregate\s'')))))))) D4;#4#9::DdUfUUUUUUUU U* P P Pc!ff$$&d##Gs1vv#G#GHHa O   "?s1vv??  s$4AC'AB'' C4 CCrrr&cKg}|d{V}||jjj}i}t |dvr d|t <tdt||D]d}||||z}| d4d{V} g} |D]~} t| tr'| | d| d\} } n| | d\} } | | | jd g| Ri|tj}| d{V}tj|z d z}t#|D]:\}}| |}|||| }| |; dddd{Vn#1d{VswxYwYf|S) aAsynchronously execute a batch of search queries. This method takes a list of search queries and executes them in batches to improve performance when dealing with multiple queries. NOTE: Cluster users may need to incorporate hash tags into their query to avoid cross-slot operations. Args: queries (List[SearchParams]): A list of search queries to execute. Each query can be either a string or a tuple of (query, params). batch_size (int, optional): The number of queries to execute in each batch. Defaults to 10. Returns: List[Result]: A list of search results corresponding to each query. .. code-block:: python queries = [ "hello world", ("goodbye world", {"num_results": 5}), ] results = await index.batch_search(queries) NrTrFrrrzrrr)rrrNrlrIr*r)rrrbrXrrr-r/rrdrr)rrrMrrrHrrrrerrMrrrrLrrrrrs rdrzAsyncSearchIndex.batch_searchts: ''))))))))4;,122  ' 'x 7 7$(GL !q#g,, 33' 6' 6A#AJ$67M 599! 6! 6! 6! 6! 6! 6! 6T&(#*E!%//(.(=(=!!H58)>)) AA)/(=(=!)>)) A(..q111(D(##" Y[[ $ ......!IKK",6(1'(:(:66$A}#6q#9L$*$8$8%*!)%9%%M  &&}555563! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6! 6Ds*DG G G cRK |d{V}t|tr8t||jjjg|Ri|d{VS||jjjj|i|d{VS#tj j $rE}dt|vrtdtdt||d}~wt$r%}tdt||d}~wwxYw)a!Perform an async search against the index. Wrapper around the search API that adds the index name to the query and passes along the rest of the arguments to the redis-py ft().search() method. Returns: Result: Raw Redis search results. Nrrrr)rrXrrrrNrlrIrHrr r!rYr/r"r2s rdrHzAsyncSearchIndex.searchs Y++--------F&"344 W1IIdk/455 FVYYt{'8'=>>EtVvVVVVVVVVV* N N Nc!ff$$&_##ESVV#E#EFFA M Y Y Y"#PA#P#PQQWX X Ys+A&B +4B D&4AC44 D& D!!D&rMcK|d{V}||jjj}||t |dstt|j d|j |j |j r|j nd|jd|d{V}d|jDS)aPerform a hybrid search against the index, combining text and vector search. Args: query (HybridQuery): The text+vector search query to be performed, with configurable fusion methods and post-processing. kwargs: Additional arguments to pass to the redis-py hybrid_search method (e.g. timeout). Returns: List[Dict[str, Any]]: The search results ordered by combined score unless otherwise specified. Notes: Hybrid search is only available in Redis 8.4.0+, and requires redis-py >= 7.1.0. .. code-block:: python from redisvl.query import HybridQuery hybrid_query = HybridQuery( text="lorem ipsum dolor sit amet", text_field_name="description", vector=[0.1, 0.2, 0.3], vector_field_name="embedding" ) results = await async_index.query(hybrid_query) Nrrc,g|]}t|Srhrrs rdrjz3AsyncSearchIndex._hybrid_search..rrfrh)rrrNrlrIrrrrrrMrrrrrL)rrMrrrlrLs rdrzAsyncSearchIndex._hybrid_searchs <'')))))))) $++011 ##E***uo.. <:;; ;++  + 3.99;;++ %             ;:'/::::rfcK|d|D|d{V}g}t||D]1\}}t|||j}||2|S)z>Asynchronously execute a batch of queries and process results.c*g|]}|j|jfSrhrrs rdrjz0AsyncSearchIndex.batch_query..rrfrNrrrs rdrzAsyncSearchIndex.batch_querys)) > >g > > >:*         $'$9$9 & & E=${F   f % % % %rfcK ||n2#t$r%}tdt||d}~wwxYw||j|jd{V}t |||jS)z3Asynchronously execute a query and process results.rNrzrrrs rdrKzAsyncSearchIndex._query's J   ' ' ' '# J J J&'AQ'A'ABB I J EKel KKKKKKKKweDKHHHHs A  AA rcZK ddlm}m}n#t$rtdwxYw|d{V}||}|d{V|||}||j|jd{V}d|j DS)a9Asynchronously execute a SQL query and return results. Args: sql_query: The SQLQuery object containing the SQL statement. Returns: List of dictionaries containing the query results. Raises: ImportError: If sql-redis package is not installed. r) AsyncExecutorAsyncSchemaRegistryrNrc,g|]}t|Srhrrs rdrjz/AsyncSearchIndex._sql_query..Mrrf) sql_redisr;r<rrrrdrrr)rrr;r<rrrrs rdrzAsyncSearchIndex._sql_query0s   D D D D D D D D D   B   ''))))))))&&v..!!!!!!!!! =22 '' i>N'OOOOOOOO::fk::::s 'c\Kt|tr||d{VSt|tr||d{VSt|t r||d{VS||d{VS)aAsynchronously execute a query on the index. This method takes a BaseQuery, AggregationQuery, HybridQuery, or SQLQuery object directly, runs the search, and handles post-processing of the search. Args: query (Union[BaseQuery, AggregationQuery, HybridQuery, SQLQuery]): The query to run. Returns: List[Result]: A list of search results. .. code-block:: python from redisvl.query import VectorQuery query = VectorQuery( vector=[0.16, -0.34, 0.98, 0.23], vector_field_name="embedding", num_results=3 ) results = await index.query(query) Nrrs rdrMzAsyncSearchIndex.queryOs4 e- . . ,//////// / x ( ( ,//////// / { + + ,,,U33333333 3U++++++++ +rfrrcKt|tstd|dkrtdd} |||||d{V}|sdS|WV||z }@)a Execute a given query against the index and return results in paginated batches. This method accepts a RedisVL query instance, enabling async pagination of results which allows for subsequent processing over each batch with a generator. Args: query (BaseQuery): The search query to be executed. page_size (int, optional): The number of results to return in each batch. Defaults to 30. Yields: An async generator yielding batches of search results. Raises: TypeError: If the page_size argument is not of type int. ValueError: If the page_size argument is less than or equal to zero. .. code-block:: python # Iterate over paginated search results in batches of 10 async for result_batch in index.paginate(query, page_size=10): # Process each batch of results pass Note: The page_size parameter controls the number of items each result batch contains. Adjust this value based on performance considerations and the expected volume of search results. Note: For stable pagination, the query must have a `sort_by` clause. zpage_size must be of type intrrTNr)rrMrfirstrLs rdrzAsyncSearchIndex.paginatersH)S)) =;<< < >>?@@ @  LL * * * KK........G MMMM Y E  rfc,K|d{V}t|tr<|}t |dd{VSt |dd{VS)rNr)rrXrrrr/)rrr*s rdrzAsyncSearchIndex.listalls '')))))))) f/ 0 0 K!1133L |'C'CJ'O'O!O!O!O!O!O!OPP P v'='=j'I'I!I!I!I!I!I!IJJ Jrfc\K|jjj|d{VvS)rNrrs rdrzAsyncSearchIndex.existss5 { %t||~~)=)=)=)=)=)===rfcK|d{V}|p|jjj}|||d{VS)rN)rrNrlrIr)rrIrrs rdrzAsyncSearchIndex.infosc''))))))))3T[.3 ZZ F333333333rfczK|jdurdS|j|jd{Vd|_dSNF)rraclosers rdrzAsyncSearchIndex.disconnectsW  "e + + F   )$++-- - - - - - - -!rfcb|j |jdurdSt|jdSrF)rrr#rrs rddisconnect_syncz AsyncSearchIndex.disconnect_syncs;   %)@E)I)I F% T_%%'''''rfc K|Srrhrs rd __aenter__zAsyncSearchIndex.__aenter__s  rfc>K|d{VdSrrrs rd __aexit__zAsyncSearchIndex.__aexit__s.oorfrrrrr)NNNNNNrrrr)?rrrrr!rAr rYrrrrrrrrrr"rrrrrrr rr!r&rr r6r<r,rUr^rfr rrsrvr5rr~r rrHrrr'rrKrrrMrrrrrrrIrKrMrhrfrdr r sV:)IJJ $(376:!&+B+B+B+BC= +B /0 +B $DcN3 +B+B+B+BKJ+BZ48#' +@+@+@/0+@C= +@+@+@[+@Z"!12"""X"$MNN & &x} & & &ON &'PQQ U3C_3T-U   RQ "#3""""0!"2O"CD 0#-=$sCx.\ PPPPLLdL$L4LLLL\SSSSSSB(d3i(C((((8%S%%%%@ -E#tCy.$9 -c - - - -,c49n(=,#,,,,>2#tCy.)2032 sDI~ 2222$(ABB#'(,!)-%)$(NHNHsmNH3-NHx}% NH c] NH X& NHc]NHSMNH cNHNHNHCBNH`chtCH~&>$  !1  d38n      2>@LLL)L7:L hLLLL\YYYY<0; 0; d38n 0;0;0;0;f;=I47 d4S>" #*I)IT#s(^0DIIII;(;tDcN7K;;;;>!,9&6 XMN!, d38n !,!,!,!,F11I1#1~1111f KtCy K K K K>d>>>> 4 4x} 4S#X 4 4 4 4"""(((      rfr )yrrSrrrwrmathrtypingrrrrrr r r r r rrrredis.exceptionsrr redis.asynciorredis.asyncio.clusterrr redis.clusterrrredisvl.query.queryrredisvl.query.sqlrredisvl.redis.utilsrrrrrrr redisvl.typesrrr redisvl.utils.utilsr!r"r#!redis.commands.search.aggregationr$redis.commands.search.documentr%redis.commands.search.resultr&r'r( redis_version redis.clientr)redisvl.utils.redis_protocolr* startswith%redis.commands.search.indexDefinitionr,&redis.commands.search.index_definitionredisvl.exceptionsr-r.r/r0r1redisvl.index.storager2r3r4 redisvl.queryr5r6r7r8r9redisvl.query.aggregater:redisvl.query.filterr;redisvl.redis.connectionr<r=r>r?redisvl.redis.constantsr@redisvl.schemarArBredisvl.schema.fieldsrCrDrErFredisvl.utils.logrGrrr"REQUIRED_MODULES_FOR_INTROSPECTIONrYr6r]bytesr r|rrrr rhrfrdrnsV   ------CCCCCC&&&&&&,,,,,,++++++&&&&&&NMMMMMMMMMVVVVVVVVVV.AAAAAA777777333333------......%%%%%%=======C   0/////HGGGGGGGGG988888111111 :9999933333333 )((((( H   Be$$ 5))&"   c9n d3c3u4556<= ? #y.  D3 D3'D31<D3 $sCx.D3D3D3D3N/ /'7/GR/ $sCx.////8x x x x x x x x vAAAAA/AAAHz z z z z z z z z z rf