j,zddlmZmZmZmZmZddlZddlZddl m Z ddl m Z m Z ddlmZddlmZddlmZed Zed ZGd d ZdS) )DictListOptionalTypeVarUnionN)utils) BaseRanker SearchResult)Replica)MilvusException)MutationResult Collection PartitionceZdZ d&deeefdededefdZdefdZdZ e defd Z e defd Z e de fd Ze defd Zd'deefdZd'deefdZd(dedeefdZd'deefdZ d'deeejejfdeedefdZd'dedeefdZ d'deeejejfdeedefdZ d)deeejfdede dedeedeeedeedede!fd Z" d*d!ed"e#dedeeedeedef d#Z$ d+dedeeedeefd$Z%d'deede&fd%Z'd S),r collectionname descriptionreturnc ddlm}t||r||_n8t|tr|||_nd}t |||_||_|ddrdS|jj |j fi|s4| }|j |jj |j fi|dSdS)Nr )rz8Collection must be of type pymilvus.Collection or String)messageconstruct_onlyF) rr isinstance _collectionstrr _name _descriptionget has_partitionr_get_connectioncreate_partition)selfrrrkwargsrmsgconns `/lsinfo/ai/hellotax_ai/base_platform/venv/lib/python3.11/site-packages/pymilvus/orm/partition.py__init__zPartition.__init__s +***** j* - - /)D    C ( ( /)z*55D  LC!#... . ' ::& . .  F-t-diBB6BB N''))D !D !$"2"7 M Mf M M M M M N NcZtj|j|jj|jdS)N)rcollection_namer)ujsondumpsrrrr#s r'__repr__zPartition.__repr__9s4{ #'#3#8#/     r)c4|jSN)rr!r.s r'r!zPartition._get_connectionBs//111r)c|jS)astr: discription of the partition. Examples: >>> from pymilvus import connections, Collection, Partition >>> connections.connect() >>> collection = Collection("test_partition_description") >>> partition = Partition(collection, "comedy", "comedy films") >>> partition.description 'comedy films' )rr.s r'rzPartition.descriptionEs   r)c|jS)acstr: name of the partition Examples: >>> from pymilvus import connections, Collection, Partition >>> connections.connect() >>> collection = Collection("test_partition_name") >>> partition = Partition(collection, "comedy", "comedy films") >>> partition.name 'comedy' )rr.s r'rzPartition.nameSs zr)c|jdkS)aqbool: whether the partition is empty Examples: >>> from pymilvus import connections, Collection, Partition >>> connections.connect() >>> collection = Collection("test_partition_is_empty") >>> partition = Partition(collection, "comedy", "comedy films") >>> partition.is_empty True r) num_entitiesr.s r'is_emptyzPartition.is_emptyas A%%r)c|}||jj|j}d|D}t |d|d<|dS)anint: number of entities in the partition Examples: >>> from pymilvus import connections >>> connections.connect() >>> from pymilvus import Collection, Partition, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_partition_num_entities", schema) >>> partition = Partition(collection, "comedy", "comedy films") >>> data = [ ... [i for i in range(10)], ... [[float(i) for i in range(2)] for _ in range(10)], ... ] >>> partition.insert(data) >>> partition.num_entities 10 )r+partition_namec(i|]}|j|jS)keyvalue).0stats r' z*Partition.num_entities..s9994$(DJ999r) row_count)r!get_partition_statsrrint)r#r&statsresults r'r5zPartition.num_entitiesoss,##%%(( ,1$))  :95999!&"566{k""r)Ntimeoutc d|}|j|jjgfd|i|dS)aSeal all segment in the collection of this partition. Inserts after flushing will be written into new segments. Only sealed segments can be indexed. 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. rEN)r!flushrrr#rEr$r&s r'rGzPartition.flushsC##%% D$)*FFGFvFFFFFr)c j|}|j|jj|jfd|i|S)aDrop the partition, the same as Collection.drop_partition 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. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import connections, Collection, Partition >>> connections.connect() >>> collection = Collection("test_partition_drop") >>> partition = Partition(collection, "comedy", "comedy films") >>> partition.drop() rE)r!drop_partitionrrrHs r'dropzPartition.drops@$##%%"t"4#3#8$)__W_X^___r)rreplica_numberc n|}|jd|jj|jg||d|S)aLoad the partition data into memory. Args: 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. Raises: MilvusException: If anything goes wrong Examples: >>> from pymilvus import connections >>> connections.connect() >>> from pymilvus import Collection, Partition, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_partition_load", schema) >>> partition = Partition(collection, "comedy", "comedy films") >>> partition.load() )r+partition_namesrLrEr:)r!load_partitionsrr)r#rLrEr$r&s r'loadzPartition.loadsV0##%%#t#  ,1!YK)       r)c l|}|jd|jj|jg|d|S)aRelease the partition 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. Raises: MilvusException: If anything goes wrong Examples: >>> from pymilvus import connections >>> connections.connect() >>> from pymilvus import Collection, Partition, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_partition_release", schema) >>> partition = Partition(collection, "comedy", "comedy films") >>> partition.load() >>> partition.release() )r+rNrEr:)r!release_partitionsrrrHs r'releasezPartition.releasesS0##%%&t&  ,1!YK      r)datac 8|jj||jfd|i|S)aInsert data into the partition, the same as Collection.insert(data, [partition]) 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): 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. 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 connections >>> connections.connect() >>> from pymilvus import Collection, Partition, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_partition_insert", schema) >>> partition = Partition(collection, "comedy", "comedy films") >>> data = [ ... [i for i in range(10)], ... [[float(i) for i in range(2)] for _ in range(10)], ... ] >>> res = partition.insert(data) >>> res.insert_count 10 rE)rinsertrr#rTrEr$s r'rVzPartition.inserts,P't&tTYRRR6RRRr)exprc 8|jj||jfd|i|S)a.Delete 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): 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. Returns: MutationResult: contains `delete_count` properties represents how many entities might be deleted. Raises: MilvusException: If anything goes wrong. Examples: >>> from pymilvus import Collection, Partition, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", DataType.FLOAT_VECTOR, dim=2) ... ]) >>> test_collection = Collection("test_partition_delete", schema) >>> test_partition = Partition(test_collection, "comedy films") >>> data = [ ... [i for i in range(10)], ... [[float(i) for i in range(2)] for _ in range(10)], ... ] >>> test_partition.insert(data) (insert count: 10, delete count: 0, upsert count: 0, timestamp: 431044482906718212) >>> test_partition.delete("film_id in [0, 1]") (insert count: 0, delete count: 2, upsert count: 0, timestamp: 431044582560759811) rE)rdeleter)r#rXrEr$s r'rZzPartition.deletes,D't&tTYRRR6RRRr)c 8|jj||jfd|i|S)aaUpsert 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): 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. 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, Partition, FieldSchema, CollectionSchema, DataType >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_partition_upsert", schema) >>> partition = Partition(collection, "comedy", "comedy films") >>> data = [ ... [i for i in range(10)], ... [[float(i) for i in range(2)] for _ in range(10)], ... ] >>> res = partition.upsert(data) >>> res.upsert_count 10 rE)rupsertrrWs r'r\zPartition.upsert>s,L't&tTYRRR6RRRr) anns_fieldparamlimit output_fields round_decimalc F|jjd||||||jg|||d | S)aConducts a vector similarity search with an optional boolean expression as filter. Args: data (``List[List[float]]`` or 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. * *nprobe*, *ef*, *search_k*, etc Corresponding search params for a certain index. * *metric_type* (``str``) similar metricy types, the value must be of type str. * *offset* (``int``, optional) offset for pagination. * *limit* (``int``, optional) limit for the search results and pagination. example for param:: { "nprobe": 128, "metric_type": "L2", "offset": 10, "limit": 10, } limit (``int``): The max number of returned record, also known as `topk`. expr (``str``): The boolean expression used to filter attribute. Default to None. example for expr:: "id_field >= 0", "id_field in [1, 2, 3, 4]" 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. **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. * *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) >>> collection.create_index( ... "films", ... {"index_type": "FLAT", "metric_type": "L2", "params": {}}) >>> partition = Partition(collection, "comedy", "comedy films") >>> # insert >>> data = [ ... [i for i in range(10)], ... [[random.random() for _ in range(2)] for _ in range(10)], ... ] >>> partition.insert(data) >>> partition.load() >>> # search >>> search_param = { ... "data": [[1.0, 1.0]], ... "anns_field": "films", ... "param": {"metric_type": "L2"}, ... "limit": 2, ... "expr": "film_id > 0", ... } >>> res = partition.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 ) rTr^r_r`rXrNrarbrEr:)rsearchr) r#rTr^r_r`rXrarErbr$s r'rdzPartition.searchfsRR't&  !!YK''      r)reqsrerankc B|jjd||||jg|||d|S)a~Conducts 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`. 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) >>> collection.create_index( ... "films", ... {"index_type": "FLAT", "metric_type": "L2", "params": {}}) >>> collection.create_index( ... "poster", ... {"index_type": "FLAT", "metric_type": "L2", "params": {}}) >>> partition = Partition(collection, "comedy", "comedy films") >>> # 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)], ... ] >>> partition.insert(data) >>> partition.load() >>> # search >>> search_param1 = { ... "data": [[1.0, 1.0]], ... "anns_field": "films", ... "param": {"metric_type": "L2"}, ... "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 = partition.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 )rerfr`rNrarbrEr:)r hybrid_searchr)r#rerfr`rarErbr$s r'rhzPartition.hybrid_searchsLz.t-  !YK''      r)c <|jjd|||jg|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. 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) >>> collection.create_index( ... "films", ... {"index_type": "FLAT", "metric_type": "L2", "params": {}}) >>> partition = Partition(collection, "comedy", "comedy films") >>> # 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)], ... ] >>> partition.insert(data) >>> partition.load() >>> # query >>> expr = "film_id in [ 0, 1 ]" >>> res = partition.query(expr, output_fields=["film_date"]) >>> assert len(res) == 2 >>> print(f"- Query results: {res}") - Query results: [{'film_id': 0, 'film_date': 2000}, {'film_id': 1, 'film_date': 2001}] )rXrarNrEr:)rqueryr)r#rXrarEr$s r'rjzPartition.querysC^&t% '!YK       r)c *|jjdd|i|S)aJGet 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. rEr:)r get_replicas)r#rEr$s r'rlzPartition.get_replicass%-t,GGWGGGGr))rr1)rN)NNNr])NNr])NN)(__name__ __module__ __qualname__rrrrr(r/r!propertyrrboolr6rBr5rfloatrGrKrPrSrpd DataFramerSparseMatrixInputTyperrVrZr\rr rdr rhrjr rlr:r)r'rrsb  NN*c/*NN N  NNNN6 #    222 !S ! ! !X ! c   X  &$ & & &X &#c###X#: G GXe_ G G G G``HUO````*  3 Xe_    B  x    F$((S(SD",(CCD(S%(S  (S(S(S(ST"S"S3"S%"S"S"S"SN$(&S&SD",(CCD&S%&S  &S&S&S&S\#-1#'T T D%556T T  T  T sm T  S *T %T T  T T T T v.2#'F F F F  F  S * F % F F F F F V.2#' U U U  S *U % U U U U n H HHUO H H H H H H Hr))typingrrrrrpandasrsr,pymilvus.clientrpymilvus.client.abstractr r pymilvus.client.typesr pymilvus.exceptionsr mutationrrrr:r)r'r}s 87777777777777 !!!!!!========))))))//////$$$$$$ W\ " " GK G HG HG HG HG HG HG HG HG HG Hr)