j7xddlZddlZddlmZmZmZmZddlZddl m Z ddl m Z m Z ddlmZddlmZmZmZmZmZddlmZmZmZmZmZmZmZddlmZdd l m!Z!d d l"m"Z"d d l#m$Z$d d l%m&Z&m'Z'd dl(m)Z)d dl*m+Z+m,Z,d dl-m.Z.d dl/m0Z0d dl1m2Z2d dl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;d dlm?Z?GddZ@dS)N)DictListOptionalUnion)utils) BaseRanker SearchResult)DEFAULT_CONSISTENCY_LEVEL)CompactionPlansCompactionStateReplicacmp_consistency_levelget_consistency_level)AutoIDExceptionDataTypeNotMatchExceptionDataTypeNotSupportExceptionExceptionsMessageIndexNotExistExceptionPartitionAlreadyExistExceptionSchemaNotReadyException) schema_pb2)Config) connections) UNLIMITED)MutationFuture SearchFuture)Index) QueryIteratorSearchIterator)MutationResult) Partition)Prepare)CollectionSchema FieldSchemacheck_insert_schema check_schemacheck_upsert_schemaconstruct_fields_from_dataframe is_row_basedis_valid_insert_data)DataType)_get_connectionceZdZ dLdedeededdfdZdefdZd Ze ded e j fd Z e defd Ze defd Ze defdZe defdZe defdZe defdZe defdZe defdZdMdeefdZdMdeefdZdMdedeefdZ dNdeededeefdZdMdeefdZ dOde!e"e j e#e$j%fdeedeede&fd Z' dOd!edeedeefd"Z( dOde!e"e j e#e$j%fdeedeede&fd#Z) dPde!e"e$j%fd%ed&e#d'ed!eedee"ed(ee"edeed)efd*Z* dQd+e"d,e+d'edee"ed(ee"edeed)efd-Z,d.e-ddddd$fde!e"e$j%fd%ed&e#d/eed'eed!eedee"ed(ee"edeed)efd0Z. dRd!ed(ee"edee"edeefd1Z/d.e-ddddfd/eed'eed!eed(ee"edee"edeef d2Z0e de"e1fd3Z2dede1fd4Z3dSded6ede1fd7Z4dMdedeedefd8Z5dMdedeefd9Z6e de"e7fd:Z8de7fd;Z9 dOdZ: dMd?ed@edeefdAZ;dMdeedefdBZ dUdeedEeede?fdGZ@ dUdeedEeede?fdHZAdMdeedeBfdIZCdMdeedeDfdJZEdMdeefdKZFdS)V CollectionNdefaultnameschemausingreturnc 8||_||_||_d|_|}|j|jfi|}|r|j|jfi|}|dt}|d|} t|| sttj tj|} ||_| | |_nt#|tsttj| |krttj||_n|ttj|zt#|trn|t-|t/|dt} |j|j|fi|||_| |_nttj|j|_|j|jd<dS)aConstructs a collection by name, schema and other parameters. Args: name (``str``): the name of collection schema (``CollectionSchema``, optional): the schema of collection, defaults to None. using (``str``, optional): Milvus connection alias name, defaults to 'default'. **kwargs (``dict``): * *num_shards (``int``, optional): how many shards will the insert data be divided. * *shards_num (``int``, optional, deprecated): how many shards will the insert data be divided. * *consistency_level* (``int/ str``) Which consistency level to use when searching in the collection. Options of consistency level: Strong, Bounded, Eventually, Session, Customized. Note: can be overwritten by the same parameter specified in search. * *properties* (``dict``, optional) Collection properties. * *timeout* (``float``) An optional duration of time in seconds to allow for the RPCs. If timeout is not set, the client keeps waiting until the server responds or an error occurs. Raises: SchemaNotReadyException: if the schema is wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> fields = [ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=128) ... ] >>> schema = CollectionSchema(fields=fields) >>> prop = {"collection.ttl.seconds": 1800} >>> collection = Collection(name="test_collection_init", schema=schema, properties=prop) >>> collection.name 'test_collection_init' Nconsistency_levelmessage)_name_using_kwargs _num_shardsr-has_collectiondescribe_collectiongetr rrrConsistencyLevelInconsistentr$construct_from_dict_consistency_level_schema isinstance SchemaTypeSchemaInconsistentCollectionNotExistNoSchemaverifyr'rcreate_collectionto_dict _schema_dict) selfr1r2r3kwargsconnhasresps_consistency_levelarg_consistency_level server_schemar6s a/lsinfo/ai/hellotax_ai/base_platform/venv/lib/python3.11/site-packages/pymilvus/orm/collection.py__init__zCollection.__init__@s=`   ##%%!d!$*7777 # T+4+DJAA&AAD"&((+>@Y"Z"Z $*JJ/BDW$X$X !()<>STT --J-@FFM&9D #~, !&*:;;X1:K:VWWWW F**1:K:^____% ~--H4O&"233 T V$$$$9JJ24MNN%%!'&tz6DDVDDD% *;''-6G6RSSSS L0022151H-...c|j|j|jd}dg}d}|D].\}}||||/d|S)N)r1 descriptionr2z: ------------- z <{}>: {} )r1rXrCitemsappendformatjoin)rL_dictrskvs rT__repr__zCollection.__repr__syI+l   . . KKMM % %DAq HHQXXa^^ $ $ $ $wwqzzrVc4tj|jSN)r_fetch_handlerr:rLs rTr-zCollection._get_connections)$+666rV dataframec Rt|tjsttj|dd}|ttjd}t|D] \}}||kr|}|dkrttj d|vrBt| dtsttj |dd}|r^||r||d}nttj| dt$j} t)| } | j|fi|r%| j|fi|} t/j| } | } nt3|}|r/||t7d |t8jd d d ||D]_}|dur|j|krd |_d|_ |j!t8j"kr+tGt$j$|j%t$j&<`t/| } tO| ||| fi|}|| }||fS)Nr7 primary_fieldauto_idFr)axisr3T)r1dtype is_primaryrl)fields)data)(rDpd DataFramerr DataFrameTypepop NoPrimaryKey enumeratePrimaryKeyNotExistr?boolr AutoIDTypeisnullalldropAutoIDWithDatarMILVUS_CONN_ALIASr-r=r>r$rAr)insertr%r,INT64r1rorlrnVARCHARintMaxVarCharLengthparamsMaxVarCharLengthKeyr')clsr1rhrMrjpk_indexifieldrlr3rNrPrSr2 fields_schema collectionress rTconstruct_from_dataframez#Collection.construct_from_dataframes)R\22 S)2C2QRRR R ?D99  )2C2PQQQ Q!),,  HAu %% r>>)2C2VWWW W   z&**Y2G2G'N'N !*;*FGGG G**Y..  X'..004466 X%NN=qNAA -6G6VWWWW 7F$<==u%% 4 t . .v . . <+4+D;;F;;D,@FFM"FF;IFFM $$*&n#' $  !    ' \ \e## m(C(C'+E$$)EM;("222?B6CZ?[?[EL!;<%];;;FVSv0000 Y//3rVc|jS)z+CollectionSchema: schema of the collection.)rCrgs rTr2zCollection.schemas |rVcn|}||j}|dS)z-List[str]: all the aliases of the collection.aliases)r-r>r9)rLrNrPs rTrzCollection.aliasess4##%%'' 33IrVc|jjS)z*str: a text description of the collection.)r2rXrgs rTrXzCollection.descriptions{&&rVc|jS)z str: the name of the collection.)r9rgs rTr1zCollection.names zrVc|jdkS)z-bool: whether the collection is empty or not.r) num_entitiesrgs rTis_emptyzCollection.is_emptys A%%rVcv|j,|d|_|jS)z-int: number of shards used by the collection.N num_shards)r<describer?rgs rTrzCollection.num_shardss4   ##}}22<@@D rVc|}||j}d|D}t|d|d<|dS)aint: The number of entities in the collection, not real time. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_num_entities", schema) >>> collection.num_entities 0 >>> collection.insert([[1, 2], [[1.0, 2.0], [3.0, 4.0]]]) >>> collection.num_entities 0 >>> collection.flush() >>> collection.num_entities 2 )collection_namec(i|]}|j|jSrrkeyvalue).0stats rT z+Collection.num_entities..s9994$(DJ999rV row_count)r-get_collection_statsr9r)rLrNstatsresults rTrzCollection.num_entitiessb(##%%))$*)EE995999!&"566{k""rVc|jjS)z1FieldSchema: the primary field of the collection.)r2rjrgs rTrjzCollection.primary_field"s{((rVtimeoutc Z|}|j|jgfd|i|dS)aSeal all segments in the collection. Inserts after flushing will be written into new segments. Only sealed segments can be indexed. Args: timeout (float): an optional duration of time in seconds to allow for the RPCs. If timeout is not set, the client keeps waiting until the server responds or an error occurs. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> fields = [ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=128) ... ] >>> schema = CollectionSchema(fields=fields) >>> collection = Collection(name="test_collection_flush", schema=schema) >>> collection.insert([[1, 2], [[1.0, 2.0], [3.0, 4.0]]]) >>> collection.flush() >>> collection.num_entities 2 rN)r-flushr1rLrrMrNs rTrzCollection.flush's>,##%% DI;:::6:::::rVc X|}|j|jfd|i|dS)aDrops the collection. The same as `utility.drop_collection()` Args: timeout (float, optional): an optional duration of time in seconds to allow for the RPCs. If timeout is not set, the client keeps waiting until the server responds or an error occurs. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_drop", schema) >>> utility.has_collection("test_collection_drop") True >>> collection.drop() >>> utility.has_collection("test_collection_drop") False rN)r-drop_collectionr9rs rTr~zCollection.drop@s=*##%%TZCCCFCCCCCrV propertiesc Z|}|j|jf||d|dS)aSSet properties for the collection Args: properties (``dict``): collection properties. support collection TTL with key `collection.ttl.seconds` support collection replica number with key `collection.replica.number` support collection resource groups with key `collection.resource_groups`. timeout (float, optional): an optional duration of time in seconds to allow for the RPCs. If timeout is not set, the client keeps waiting until the server responds or an error occurs. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> fields = [ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=128) ... ] >>> schema = CollectionSchema(fields=fields) >>> collection = Collection("test_set_properties", schema) >>> collection.set_properties({"collection.ttl.seconds": 60}) )rrN)r-alter_collectionr1)rLrrrMrNs rTset_propertieszCollection.set_propertiesXsU,##%% I !        rVrpartition_namesreplica_numberc |}||jd|j|||d|dS|jd|j||d|dS)a4Load the data into memory. Args: partition_names (``List[str]``): The specified partitions to load. replica_number (``int``, optional): The replica number to load, defaults to 1. timeout (float, optional): an optional duration of time in seconds to allow for the RPCs. If timeout is not set, the client keeps waiting until the server responds or an error occurs. **kwargs (``dict``, optional): * *_async*(``bool``) Indicate if invoke asynchronously. * *refresh*(``bool``) Whether to renew the segment list of this collection before loading * *resource_groups(``List[str]``) Specify resource groups which can be used during loading. * *load_fields(``List[str]``) Specify load fields list needed during this load * *skip_load_dynamic_field(``bool``) Specify whether this load shall skip dynamic schmea field Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> connections.connect() >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_load", schema) >>> collection.insert([[1, 2], [[1.0, 2.0], [3.0, 4.0]]]) >>> index_param = {"index_type": "FLAT", "metric_type": "L2", "params": {}} >>> collection.create_index("films", index_param) >>> collection.load() N)rrrr)rrrrr)r-load_partitionsr9load_collection)rLrrrrMrNs rTloadzCollection.loadvsZ##%%  & D   $ /-           !D   $ -        rVc X|}|j|jfd|i|dS)aReleases the collection data from memory. Args: timeout (float, optional): an optional duration of time in seconds to allow for the RPCs. If timeout is not set, the client keeps waiting until the server responds or an error occurs. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_release", schema) >>> collection.insert([[1, 2], [[1.0, 2.0], [3.0, 4.0]]]) >>> index_param = {"index_type": "FLAT", "metric_type": "L2", "params": {}} >>> collection.create_index("films", index_param) >>> collection.load() >>> collection.release() rN)r-release_collectionr9rs rTreleasezCollection.releases=*##%% FFGFvFFFFFrVrqpartition_namec Xt|std|}t|r|jd|j||||jd|St|j|tj ||j}|j |j||f||jd|S)a[Insert data into the collection. Args: data (``list/tuple/pandas.DataFrame/sparse types``): The specified data to insert partition_name (``str``): The partition name which the data will be inserted to, if partition name is not passed, then the data will be inserted to default partition timeout (float, optional): an optional duration of time in seconds to allow for the RPCs. If timeout is not set, the client keeps waiting until the server responds or an error occurs. Returns: MutationResult: contains 2 properties `insert_count`, and, `primary_keys` `insert_count`: how may entites have been inserted into Milvus, `primary_keys`: list of primary keys of the inserted entities Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> import random >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_insert", schema) >>> data = [ ... [random.randint(1, 100) for _ in range(10)], ... [[random.random() for _ in range(2)] for _ in range(10)], ... ] >>> res = collection.insert(data) >>> res.insert_count 10 5The type of data should be List, pd.DataFrame or Dictr7)rentitiesrrr2rr2rr) r+rr-r* insert_rowsr9rKr&r2r# prepare_data batch_insert)rLrqrrrMrNrs rTrzCollection.insertsP$D)) -O ##%%    #4# $ -(     DK...'dk:: t J   $       rVexprc |}|j|j||fd|i|}|ddrt |St |S)aVDelete entities with an expression condition. Args: expr (``str``): The specified data to insert. partition_names (``List[str]``): Name of partitions to delete entities. timeout (float, optional): an optional duration of time in seconds to allow for the RPCs. If timeout is not set, the client keeps waiting until the server responds or an error occurs. **kwargs (``dict``): Optional search params * *consistency_level* (``str/int``, optional) Which consistency level to use when searching in the collection. Options of consistency level: Strong, Bounded, Eventually, Session, Customized. Note: this parameter overwrites the same one specified when creating collection, if no consistency level was specified, search will use the consistency level when you create the collection. Returns: MutationResult: contains `delete_count` properties represents how many entities might be deleted. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> import random >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("film_date", DataType.INT64), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2), ... ]) >>> collection = Collection("test_collection_delete", schema) >>> # insert >>> data = [ ... [i for i in range(10)], ... [i + 2000 for i in range(10)], ... [[random.random() for _ in range(2)] for _ in range(10)], ... ] >>> collection.insert(data) >>> res = collection.delete("film_id in [ 0, 1 ]") >>> print(f"- Deleted entities: {res}") - Delete results: [0, 1] r_asyncF)r-deleter9r?rr!)rLrrrrMrNrs rTrzCollection.deletesll##%%dk$*dNVVGVvVV ::h & & '!#&& &c"""rVc t|std|}t|r,|j|j||f||jd|}t|St|j |tj ||j d}|j |j||f||jd|}| ddrt|nt|S)aYUpsert data into the collection. Args: data (``list/tuple/pandas.DataFrame/sparse types``): The specified data to upsert partition_name (``str``): The partition name which the data will be upserted at, if partition name is not passed, then the data will be upserted in default partition timeout (float, optional): an optional duration of time in seconds to allow for the RPCs. If timeout is not set, the client keeps waiting until the server responds or an error occurs. Returns: MutationResult: contains 2 properties `upsert_count`, and, `primary_keys` `upsert_count`: how may entites have been upserted at Milvus, `primary_keys`: list of primary keys of the upserted entities Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> import random >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_upsert", schema) >>> data = [ ... [random.randint(1, 100) for _ in range(10)], ... [[random.random() for _ in range(2)] for _ in range(10)], ... ] >>> res = collection.upsert(data) >>> res.upsert_count 10 rr7rFr)r+rr-r* upsert_rowsr9rKr!r(r2r#rupsertr?r)rLrqrrrMrNrrs rTrzCollection.upsertKs6R$D)) -O ##%%    '"$"  (   C"#&& &DK...'dk5AAdk J   $      '-jj5&A&AZ~c"""~VYGZGZZrVrk anns_fieldparamlimit output_fields round_decimalc |?t|ts*ttjt |zt j|o|j ddk} t|trt|dks| rGttj} | ddrt!dn| S|} | j|j|||||||| f ||jd| } | ddrt!| n| S)aConducts a vector similarity search with an optional boolean expression as filter. Args: data (``List[List[float]]/sparse types``): The vectors of search data. the length of data is number of query (nq), and the dim of every vector in data must be equal to the vector field of collection. anns_field (``str``): The name of the vector field used to search of collection. param (``dict[str, Any]``): The parameters of search. The followings are valid keys of param. * *metric_type* (``str``) similar metricy types, the value must be of type str. * *offset* (``int``, optional) offset for pagination. * *params of index: *nprobe*, *ef*, *search_k*, etc Corresponding search params for a certain index. example for param:: { "metric_type": "L2", "offset": 10, "params": {"nprobe": 12}, } limit (``int``): The max number of returned record, also known as `topk`. expr (``str``, Optional): The boolean expression used to filter attribute. example for expr:: "id_field >= 0", "id_field in [1, 2, 3, 4]" partition_names (``List[str]``, optional): The names of partitions to search on. output_fields (``List[str]``, optional): The name of fields to return in the search result. Can only get scalar fields. round_decimal (``int``, optional): The specified number of decimal places of returned distance. Defaults to -1 means no round to returned distance. timeout (``float``, optional): A duration of time in seconds to allow for the RPC. If timeout is set to None, the client keeps waiting until the server responds or an error occurs. **kwargs (``dict``): Optional search params * *_async* (``bool``, optional) Indicate if invoke asynchronously. Returns a SearchFuture if True, else returns results from server directly. * *_callback* (``function``, optional) The callback function which is invoked after server response successfully. It functions only if _async is set to True. * *offset* (``int``, optinal) offset for pagination. * *consistency_level* (``str/int``, optional) Which consistency level to use when searching in the collection. Options of consistency level: Strong, Bounded, Eventually, Session, Customized. Note: this parameter overwrites the same one specified when creating collection, if no consistency level was specified, search will use the consistency level when you create the collection. * *guarantee_timestamp* (``int``, optional) Instructs Milvus to see all operations performed before this timestamp. By default Milvus will search all operations performed to date. Note: only valid in Customized consistency level. * *graceful_time* (``int``, optional) Search will use the (current_timestamp - the graceful_time) as the `guarantee_timestamp`. By default with 5s. Note: only valid in Bounded consistency level Returns: SearchResult: Returns ``SearchResult`` if `_async` is False , otherwise ``SearchFuture`` .. _Metric type documentations: https://milvus.io/docs/v2.2.x/metric.md .. _Index documentations: https://milvus.io/docs/v2.2.x/index.md .. _How guarantee ts works: https://github.com/milvus-io/milvus/blob/master/docs/developer_guides/how-guarantee-ts-works.md Raises: MilvusException: If anything goes wrong Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> import random >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_search", schema) >>> # insert >>> data = [ ... [i for i in range(10)], ... [[random.random() for _ in range(2)] for _ in range(10)], ... ] >>> collection.insert(data) >>> index_param = {"index_type": "FLAT", "metric_type": "L2", "params": {}} >>> collection.create_index("films", index_param) >>> collection.load() >>> # search >>> search_param = { ... "data": [[1.0, 1.0]], ... "anns_field": "films", ... "param": {"metric_type": "L2", "offset": 1}, ... "limit": 2, ... "expr": "film_id > 0", ... } >>> res = collection.search(**search_param) >>> assert len(res) == 1 >>> hits = res[0] >>> assert len(hits) == 2 >>> print(f"- Total hits: {len(hits)}, hits ids: {hits.ids} ") - Total hits: 2, hits ids: [8, 5] >>> print(f"- Top1 hit id: {hits[0].id}, score: {hits[0].score} ") - Top1 hit id: 8, score: 0.10143111646175385 Nr7rrFr)rDstrrrExprTypetyper SciPyHelperis_scipy_sparseshapelistlenr rSearchResultDatar?rr-searchr9rK)rLrqrrrrrrrrrMempty_scipy_sparserPrNs rTrzCollection.searchsQL  JtS$9$9 +4E4NQUVZQ[Q[4[\\\ \".>>tDD]$*UV-[\J\ tT " " Os4yyA~~:L~ ; = =>>D)/He)D)DN<%%%$ N##%%t{ J          $      &,ZZ%%@%@J|D!!!dJrVreqsrerankc t|trZt|dkrGtt j} |ddrtdn| S|} | j |j ||||||f||j d|} |ddrt| n| S)aJConducts multi vector similarity search with a rerank for rearrangement. Args: reqs (``List[AnnSearchRequest]``): The vector search requests. rerank (``BaseRanker``): The reranker for rearrange nummer of limit results. limit (``int``): The max number of returned record, also known as `topk`. partition_names (``List[str]``, optional): The names of partitions to search on. output_fields (``List[str]``, optional): The name of fields to return in the search result. Can only get scalar fields. round_decimal (``int``, optional): The specified number of decimal places of returned distance. Defaults to -1 means no round to returned distance. timeout (``float``, optional): A duration of time in seconds to allow for the RPC. If timeout is set to None, the client keeps waiting until the server responds or an error occurs. **kwargs (``dict``): Optional search params * *_async* (``bool``, optional) Indicate if invoke asynchronously. Returns a SearchFuture if True, else returns results from server directly. * *_callback* (``function``, optional) The callback function which is invoked after server response successfully. It functions only if _async is set to True. * *offset* (``int``, optinal) offset for pagination. * *consistency_level* (``str/int``, optional) Which consistency level to use when searching in the collection. Options of consistency level: Strong, Bounded, Eventually, Session, Customized. Note: this parameter overwrites the same one specified when creating collection, if no consistency level was specified, search will use the consistency level when you create the collection. * *guarantee_timestamp* (``int``, optional) Instructs Milvus to see all operations performed before this timestamp. By default Milvus will search all operations performed to date. Note: only valid in Customized consistency level. * *graceful_time* (``int``, optional) Search will use the (current_timestamp - the graceful_time) as the `guarantee_timestamp`. By default with 5s. Note: only valid in Bounded consistency level Returns: SearchResult: Returns ``SearchResult`` if `_async` is False , otherwise ``SearchFuture`` .. _Metric type documentations: https://milvus.io/docs/v2.2.x/metric.md .. _Index documentations: https://milvus.io/docs/v2.2.x/index.md .. _How guarantee ts works: https://github.com/milvus-io/milvus/blob/master/docs/developer_guides/how-guarantee-ts-works.md Raises: MilvusException: If anything goes wrong Examples: >>> from pymilvus import (Collection, FieldSchema, CollectionSchema, DataType, >>> AnnSearchRequest, RRFRanker, WeightedRanker) >>> import random >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2), ... FieldSchema("poster", dtype=DataType.FLOAT_VECTOR, dim=2), ... ]) >>> collection = Collection("test_collection_search", schema) >>> # insert >>> data = [ ... [i for i in range(10)], ... [[random.random() for _ in range(2)] for _ in range(10)], ... [[random.random() for _ in range(2)] for _ in range(10)], ... ] >>> collection.insert(data) >>> index_param = {"index_type": "FLAT", "metric_type": "L2", "params": {}} >>> collection.create_index("films", index_param) >>> collection.create_index("poster", index_param) >>> collection.load() >>> # search >>> search_param1 = { ... "data": [[1.0, 1.0]], ... "anns_field": "films", ... "param": {"metric_type": "L2", "offset": 1}, ... "limit": 2, ... "expr": "film_id > 0", ... } >>> req1 = AnnSearchRequest(**search_param1) >>> search_param2 = { ... "data": [[2.0, 2.0]], ... "anns_field": "poster", ... "param": {"metric_type": "L2", "offset": 1}, ... "limit": 2, ... "expr": "film_id > 0", ... } >>> req2 = AnnSearchRequest(**search_param2) >>> res = collection.hybrid_search([req1, req2], WeightedRanker(0.9, 0.1), 2) >>> assert len(res) == 1 >>> hits = res[0] >>> assert len(hits) == 2 >>> print(f"- Total hits: {len(hits)}, hits ids: {hits.ids} ") - Total hits: 2, hits ids: [8, 5] >>> print(f"- Top1 hit id: {hits[0].id}, score: {hits[0].score} ") - Top1 hit id: 8, score: 0.10143111646175385 rrFNr) rDrrr rrr?rr- hybrid_searchr9rK) rLrrrrrrrrMrPrNs rTrzCollection.hybrid_search2st dD ! ! Oc$ii1nn ; = =>>D)/He)D)DN<%%%$ N##%%!t! J        $      &,ZZ%%@%@J|D!!!dJrVi batch_sizec  |?t|ts*ttjt |zt d||j||||||||| | |j d | S)Nr7) connectionrrq ann_fieldrrrrrrrrr2rr) rDrrrrrr r-r9rK) rLrqrrrrrrrrrrMs rTsearch_iteratorzCollection.search_iterators  JtS$9$9 +4E4NQUVZQ[Q[4[\\\ \ ++-- J !+''$     rVc t|ts*ttjt |z|}|j|j|||f||j d|S)a Query with expressions Args: expr (``str``): The query expression. output_fields(``List[str]``): A list of field names to return. Defaults to None. partition_names: (``List[str]``, optional): A list of partition names to query in. timeout (``float``, optional): A duration of time in seconds to allow for the RPC. If timeout is set to None, the client keeps waiting until the server responds or an error occurs. **kwargs (``dict``, optional): * *consistency_level* (``str/int``, optional) Which consistency level to use when searching in the collection. Options of consistency level: Strong, Bounded, Eventually, Session, Customized. Note: this parameter overwrites the same one specified when creating collection, if no consistency level was specified, search will use the consistency level when you create the collection. * *guarantee_timestamp* (``int``, optional) Instructs Milvus to see all operations performed before this timestamp. By default Milvus will search all operations performed to date. Note: only valid in Customized consistency level. * *graceful_time* (``int``, optional) Search will use the (current_timestamp - the graceful_time) as the `guarantee_timestamp`. By default with 5s. Note: only valid in Bounded consistency level * *offset* (``int``) Combined with limit to enable pagination * *limit* (``int``) Combined with limit to enable pagination Returns: List, contains all results Raises: MilvusException: If anything goes wrong Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> import random >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("film_date", DataType.INT64), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_query", schema) >>> # insert >>> data = [ ... [i for i in range(10)], ... [i + 2000 for i in range(10)], ... [[random.random() for _ in range(2)] for _ in range(10)], ... ] >>> collection.insert(data) >>> index_param = {"index_type": "FLAT", "metric_type": "L2", "params": {}} >>> collection.create_index("films", index_param) >>> collection.load() >>> # query >>> expr = "film_id <= 1" >>> res = collection.query(expr, output_fields=["film_date"], offset=1, limit=1) >>> assert len(res) == 1 >>> print(f"- Query results: {res}") - Query results: [{'film_id': 1, 'film_date': 2001}] r7r) rDrrrrrr-queryr9rK)rLrrrrrMrNs rTrzCollection.querys^$$$ ]+4E4NQUVZQ[Q[4[\\\ \##%%tz J     $      rVc |?t|ts*ttjt |zt d||j||||||j |d |S)Nr7) rrrrrrrr2rrr) rDrrrrrrr-r9rK)rLrrrrrrrMs rTquery_iteratorzCollection.query_iterator>s  JtS$9$9 +4E4NQUVZQ[Q[4[\\\ \  ++-- J!'+$      rVc|}||j}g}|D]'}|t ||d(|S)a{List[Partition]: List of Partition object. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_partitions", schema) >>> collection.partitions [{"name": "_default", "description": "", "num_entities": 0}] T)construct_only)r-list_partitionsr9r[r")rLrNpartition_strs partitions partitions rTrzCollection.partitionsWsl"##%%--dj99 ' O OI   iiMMM N N N NrVc B|j|fi|sdSt||fddi|S)a[Get the existing partition object according to name. Return None if not existed. Args: partition_name (``str``): The name of the partition to get. Returns: Partition: Partition object corresponding to partition_name. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_partition", schema) >>> collection.partition("_default") {"name": "_default", "description": "", "num_entities": 0} NrT) has_partitionr")rLrrMs rTrzCollection.partitionosC,"t!.;;F;; 4~MMdMfMMMrVrYrXc v|j|fi|durttjt ||fd|i|S)a[Create a new partition corresponding to name if not existed. Args: partition_name (``str``): The name of the partition to create. description (``str``, optional): The description of this partition. Returns: Partition: Partition object corresponding to partition_name. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_create_partition", schema) >>> collection.create_partition("comedy", description="comedy films") {"name": "comedy", "collection_name": "test_create_partition", "description": ""} >>> collection.partition("comedy") {"name": "comedy", "collection_name": "test_create_partition", "description": ""} Tr7rX)rrrPartitionAlreadyExistr")rLrrXrMs rTcreate_partitionzCollection.create_partitionsV2 4 n 7 7 7 74 ? ?09J9`aaa a~QQ;Q&QQQrVc V|}|j|j|fd|i|S)aChecks if a specified partition exists. Args: partition_name (``str``): The name of the partition to check. timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. Returns: bool: True if exists, otherwise false. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_has_partition", schema) >>> collection.create_partition("comedy", description="comedy films") {"name": "comedy", "description": "comedy films", "num_entities": 0} >>> collection.has_partition("comedy") True >>> collection.has_partition("science_fiction") False r)r-rr9rLrrrMrNs rTrzCollection.has_partitions::##%%!t!$*nXXgXQWXXXrVc V|}|j|j|fd|i|S)aDrop the partition in this collection. Args: partition_name (``str``): The name of the partition to drop. timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_drop_partition", schema) >>> collection.create_partition("comedy", description="comedy films") {"name": "comedy", "description": "comedy films", "num_entities": 0} >>> collection.has_partition("comedy") True >>> collection.drop_partition("comedy") >>> collection.has_partition("comedy") False r)r-drop_partitionr9rs rTrzCollection.drop_partitions:6##%%"t"4:~YYwYRXYYYrVc`|}g}||j}|D]z}|vd|jD}|drt j|d|d<t||j||j d}| |{|S)aList[Index]: list of indexes of this collection. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_indexes", schema) >>> collection.indexes [] Nc(i|]}|j|jSrrr)rkvs rTrz&Collection.indexes..sEEE"RVRXEEErVrT)r field_name index_params index_namer) r- list_indexesr9rr?jsonloadsrrrr[)rLrNindexes tmp_indexindex info_dict index_infos rTrzCollection.indexess##%%%%dj11  + +E EE EEE ==**J*.*Yx5H*I*IIh'"#$/!*$/#'  z***rVc tj|}|dtj}|}|j|j|fi|}||dd}|d|}|d|d|d|dt|||d| Sttj ) aGet the index object of index name. Args: **kwargs (``dict``): * *index_name* (``str``) The name of index. If no index is specified, the default index name is used. Returns: Index: Index object corresponding to index_name. Raises: IndexNotExistException: If the index doesn't exists. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_index", schema) >>> index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"} >>> collection.create_index("films", index) Status(code=0, message='') >>> collection.indexes [] >>> collection.index() rNr total_rows indexed_rowspending_index_rowsstateT)rrr7) copydeepcopyrvr IndexNamer-describe_indexr9rrr IndexNotExist)rLrM copy_kwargsrrNrrs rTrzCollection.indexs:mF++  __\63CDD ##%%'D' JNN+NN  "|T::J"|Z@@J MM, ' ' ' MM. ) ) ) MM. / / / MM' " " "z9TV`aaa a$->-LMMMMrVrrc X|}|j|j||fd|i|S)aCreates index for a specified field, with a index name. Args: field_name (``str``): The name of the field to create index index_params (``dict``, optional): The parameters to index * *index_type* (``str``) "index_type" as the key, example values: "FLAT", "IVF_FLAT", etc. * *metric_type* (``str``) "metric_type" as the key, examples values: "L2", "IP", "JACCARD". * *params* (``dict``) "params" as the key, corresponding index params. timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. index_name (``str``): The name of index which will be created, must be unique. If no index name is specified, the default index name will be used. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_create_index", schema) >>> index_params = { ... "index_type": "IVF_FLAT", ... "params": {"nlist": 128}, ... "metric_type": "L2"} >>> collection.create_index("films", index_params, index_name="idx") Status(code=0, message='') r)r- create_indexr9)rLrrrrMrNs rTrzCollection.create_index0s=X##%% t ZaawaZ`aaarVr extra_paramscf|}||j|||S)aAlter index for a specified field, with a index name. Args: index_name (``str``): The name of the index to alter extra_params (``dict``): The parameters to index * *mmap.enabled* (``str``) "mmap.enabled" as the key, example values: True or False. timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> from pymilvus import IndexType, MetricType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("title", DataType.STRING), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_alter_index", schema) >>> index_params = { ... "index_type": IndexType.IVF_FLAT, ... "metric_type": MetricType.L2, ... "params": {"nlist": 128} ... } >>> collection.create_index("films", index_params, index_name="idx") Status(code=0, message='') >>> collection.alter_index("idx", {"mmap.enabled": True}) r)r- alter_indexr9)rLrrrrNs rTrzCollection.alter_index_s5N##%% J gVVVrVc |}tj|}|dtj}|j|j|fd|i|duS)asCheck whether a specified index exists. Args: timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. **kwargs (``dict``): * *index_name* (``str``) The name of index. If no index is specified, the default index name will be used. Returns: bool: Whether the specified index exists. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_has_index", schema) >>> index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"} >>> collection.create_index("films", index) >>> collection.has_index() True rrN)r-r r rvrr rr9)rLrrMrNrrs rT has_indexzCollection.has_indexsh6##%%mF++  __\63CDD  D  J W W W; W W_c c rVc tj|}|dtj}|}|j|j|fd|i|}||jd|j|d||d|dSdS)aDrop index and its corresponding index files. Args: timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. **kwargs (``dict``): * *index_name* (``str``) The name of index. If no index is specified, the default index name will be used. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus Collection, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_has_index", schema) >>> index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"} >>> collection.create_index("films", index) >>> collection.has_index() True >>> collection.drop_index() >>> collection.has_index() False rrNr)rrrrrr) r r rvrr r-rr9 drop_index)rLrrMrrrNrs rTrzCollection.drop_indexs:mF++  __\63CDD ##%%'D' J___S^__  DO  $ $\2%           ! rVF is_clusteringc |}|r|j|jf||d||_dS|j|jf||d||_dS)aCompact merge the small segments in a collection Args: timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. is_clustering (``bool``, optional): Option to trigger clustering compaction. Raises: MilvusException: If anything goes wrong. )rrN)r-compactr9clustering_compaction_id compaction_id)rLrrrMrNs rTrzCollection.compacts##%%  ,8DL -*7--LR--D ) ) )". "*7""LR""D   rVc |}|r|j|jfd|i|S|j|jfd|i|S)aGet the current compaction state Args: timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. is_clustering (``bool``, optional): Option to get clustering compaction state. Raises: MilvusException: If anything goes wrong. r)r-get_compaction_staterrrLrrrMrNs rTr!zCollection.get_compaction_statesu##%%  ,4,-7>BH )t();WWWWPVWWWrVc |}|r|j|jfd|i|S|j|jfd|i|S)aBlock until the current collection's compaction completed Args: timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. is_clustering (``bool``, optional): Option to get clustering compaction state. Raises: MilvusException: If anything goes wrong. r)r-wait_for_compaction_completedrrr"s rTr$z(Collection.wait_for_compaction_completedsu$##%%  545-7>BH 2t1$2D``g`Y_```rVc T|}|j|jfd|i|S)aiGet the current compaction plans Args: timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. Returns: CompactionPlans: All the plans' states of this compaction. r)r-get_compaction_plansrrs rTr&zCollection.get_compaction_planss9##%%(t();WWWWPVWWWrVc T|}|j|jfd|i|S)a^Get the current loaded replica information Args: timeout (``float``, optional): An optional duration of time in seconds to allow for the RPC. When timeout is set to None, client waits until server response or error occur. Returns: Replica: All the replica information. r)r- get_replicasr1rs rTr(zCollection.get_replicas+s7##%% t FFGFvFFFrVcb|}||j|S)Nr)r-r>r1)rLrrNs rTrzCollection.describe8s.##%%'' 7'CCCrV)Nr0re)NrN)NN)NNNNrk)NNNrk)NNN)rY)FN)NF)G__name__ __module__ __qualname__rrr$rUrcr- classmethodrsrtrpropertyr2rrrXr1rzrrrrr%rjfloatrr~dictrrrrrrrSparseMatrixInputTyper!rrrrrrrrrrr"rrrrrrrrrrrrrr r!r$r r&r r(rrrrVrTr/r/?s .2 ]I]I]I)*]I ]I  ]I]I]I]I~ #    7774C4BL444[4l(XX 'S'''X'cX&$&&&X& C   X #c###X#2){)))X);;Xe_;;;;2DDHUODDDD0       @+/#' <<!$<<% <<<<|GGxGGGG6)-#' A A D",e.IIJA ! A % A  A A A A L)-#' :#:#:#! :#% :#:#:#:#~)-#' E[E[D",e.IIJE[! E[% E[  E[E[E[E[Z#/3-1#'^K^KD%556^K^K ^K  ^K sm ^K"$s),^K S *^K%^K^K^K^K^KJ04-1#'LKLKLKLK LK "$s), LK  S * LK%LKLKLKLKLKf%)("/3-1#'  D%556    SM  }  sm "$s),  S * %     H.2/3#' [ [ [  S *[ "$s), [ % [ [ [ [ ~%)("-1/3#'  SM } sm   S *  "$s),  %    2DOX.NN)NNNN4RRsRRXaRRRR:YYCY(5/Y_cYYYY@ZZSZ8E?ZZZZ<eX@)N)N)N)N)N\(,#' -b-b-btn-b% -b-b-b-bf$( (W(W(W(W% (W(W(W(WT! ! %! d! ! ! ! F(((5/((((VQU%d^>Fuo4PUXXX>FtnX XXXX0$((-aa%a ~a  aaaa2 X XHUO XQ` X X X X G GHUO G G G G GDDDDDDDDrVr/)Ar rtypingrrrrpandasrspymilvus.clientrpymilvus.client.abstractrr pymilvus.client.constantsr pymilvus.client.typesr r r rrpymilvus.exceptionsrrrrrrrpymilvus.grpc_genrpymilvus.settingsrr constantsrfuturerrrriteratorrr mutationr!rr"preparer#r2r$r%r&r'r(r)r*r+typesr,utilityr-r/rrrVrTrBs ............!!!!!!========??????)((((($$$$$$$$$$$$ 0000000033333333$$$$$$                     $$$$$${D{D{D{D{D{D{D{D{D{DrV