jddlmZmZmZddlmZmZmZddlmZm Z ddl m Z ddl m Zddl mZddl mZddlmZd d lmZd_d ededeefdZd_dededeefdZ d_dededeefdZ d`d edeefdZd efdZ defdZ dadedeeededeefdZ dadedeeededeefd Z dbdedeeedeedefd!Z dcded#ededeefd$Z ddded#edeedefd%Zdedededeefd&Z deded'ededeed(e!f d)Z"dfdedeedefd*Z# ddd+ed,ed-edeedef d.Z$dfdeeded(e%fd/Z& dgded0ed1eeed2eeedeedef d3Z' dfdedeedefd4Z( dfdededeedefd5Z)dfdedeedefd6Z* dfdededeedefd7Z+dfdedeedefd8Z, dbded9eed'eedeeded(ef d:Z- dfd;edeeded(efd<Z. dhd=edeedeeded(e%f d>Z/ ded?ed@edAededeef dBZ0 ded?edCededeefdDZ1 ded?ed@edAededeef dEZ2ded?ededeefdFZ3dededeefdGZ4dedHe!dedeefdIZ5 dedJedKe!dedeefdLZ6dedKe!dedeefdMZ7dededeed(efdNZ8 dedOededeefdPZ9 dedQeee fdedeefdRZ:dedOededeefdSZ;dedOededeefdTZ dedVedWededZededeef d[Z?dededeefd\Z@didefd]ZA dedededeefd^ZBd S)j)datetime timedeltatimezone)ListMappingOptional)BulkInsertStateResourceGroupConfig)hybridts_to_unixtime)mkts_from_datetime)mkts_from_hybridts)mkts_from_unixtime)MilvusException) connectionsNhybridts millisecondsdeltac&t|||S)aZGenerate a hybrid timestamp based on an existing hybrid timestamp, timedelta and incremental time internval. :param hybridts: The original hybrid timestamp used to generate a new hybrid timestamp. Non-negative interger range from 0 to 18446744073709551615. :type hybridts: int :param milliseconds: Incremental time interval. The unit of time is milliseconds. :type milliseconds: float :param delta: A duration expressing the difference between two date, time, or datetime instances to microsecond resolution. :type delta: datetime.timedelta :return int: Hybrid timetamp is a non-negative interger range from 0 to 18446744073709551615. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> _DIM = 128 >>> field_int64 = FieldSchema("int64", DataType.INT64, description="int64", is_primary=True) >>> field_vector = FieldSchema("float_vector", DataType.FLOAT_VECTOR, dim=_DIM) >>> schema = CollectionSchema(fields=[field_int64, field_vector]) >>> collection = Collection(name="test_collection", schema=schema) >>> import pandas as pd >>> int64_series = pd.Series(data=list(range(10, 20)), index=list(range(10)))i >>> float_vector_series = [[random.random() for _ in range _DIM] for _ in range (10)] >>> data = pd.DataFrame({"int64" : int64_series, "float_vector": float_vector_series}) >>> m = collection.insert(data) >>> ts_new = utility.mkts_from_hybridts(m.timestamp, milliseconds=1000.0) rr)_mkts_from_hybridts)rrrs ^/lsinfo/ai/hellotax_ai/base_platform/venv/lib/python3.11/site-packages/pymilvus/orm/utility.pyr r s@ xl% P P PPepochc&t|||S)a Generate a hybrid timestamp based on Unix Epoch time, timedelta and incremental time internval. :param epoch: The known Unix Epoch time used to generate a hybrid timestamp. The Unix Epoch time is the number of seconds that have elapsed since January 1, 1970 (midnight UTC/GMT). :type epoch: float :param milliseconds: Incremental time interval. The unit of time is milliseconds. :type milliseconds: float :param delta: A duration expressing the difference between two date, time, or datetime instances to microsecond resolution. :type delta: datetime.timedelta :return int: Hybrid timetamp is a non-negative interger range from 0 to 18446744073709551615. :example: >>> import time >>> from pymilvus import utility >>> epoch_t = time.time() >>> ts = utility.mkts_from_unixtime(epoch_t, milliseconds=1000.0) r)_mkts_from_unixtime)rrrs rrr@s2 u>> import datetime >>> from pymilvus import utility >>> d = datetime.datetime.now() >>> ts = utility.mkts_from_datetime(d, milliseconds=1000.0) r)_mkts_from_datetime)rrrs rr r \s2 vL N N NNrtzcddl}|'t||jsd}t|t |}|j||S)a* Convert a hybrid timestamp to the datetime according to timezone. :param hybridts: The known hybrid timestamp to convert to datetime. Non-negative interger range from 0 to 18446744073709551615. :type hybridts: int :param tz: Timezone defined by a fixed offset from UTC. If argument tz is None or not specified, the hybridts is converted to the platform`s local date and time. :type tz: datetime.timezone :return datetime: The datetime object. :raises Exception: If parameter tz is not of type datetime.timezone. :example: >>> import time >>> from pymilvus import utility >>> epoch_t = time.time() >>> ts = utility.mkts_from_unixtime(epoch_t) >>> d = utility.hybridts_to_datetime(ts) rNz0parameter tz should be type of datetime.timezone)message)r!)r isinstancerr_hybridts_to_unixtime fromtimestamp)rr!rmsgrs rhybridts_to_datetimer(xsb.OOO ~jX->??~@c**** !( + +E   * *5R * 8 88rc t|S)a Convert a hybrid timestamp to UNIX Epoch time ignoring the logic part. :param hybridts: The known hybrid timestamp to convert to UNIX Epoch time. Non-negative interger range from 0 to 18446744073709551615. :type hybridts: int :return float: The Unix Epoch time is the number of seconds that have elapsed since January 1, 1970 (midnight UTC/GMT). :example: >>> import time >>> from pymilvus import utility >>> epoch1 = time.time() >>> ts = utility.mkts_from_unixtime(epoch1) >>> epoch2 = utility.hybridts_to_unixtime(ts) >>> assert epoch1 == epoch2 )r%)rs rr r s( ! * **raliasc*tj|SN)r_fetch_handler)r*s r_get_connectionr.s  %e , ,,rdefaultcollection_namepartition_namesusingtimeoutc\t||||}d|ddiS)a\Show loading progress of sealed segments in percentage. :param collection_name: The name of collection is loading :type collection_name: str :param partition_names: The names of partitions is loading :type partition_names: str list :return dict: {'loading_progress': '100%'} :raises MilvusException: If anything goes wrong. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> import pandas as pd >>> import random >>> fields = [ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", DataType.FLOAT_VECTOR, dim=8), ... ] >>> schema = CollectionSchema(fields) >>> collection = Collection("test_loading_progress", schema) >>> data = pd.DataFrame({ ... "film_id" : pd.Series(data=list(range(10, 20)), index=list(range(10))), ... "films": [[random.random() for _ in range(8)] for _ in range (10)], ... }) >>> collection.insert(data) >>> collection.create_index( ... "films", ... {"index_type": "IVF_FLAT", "params": {"nlist": 8}, "metric_type": "L2"}) >>> collection.load(_async=True) >>> utility.loading_progress("test_loading_progress") {'loading_progress': '100%'} r3loading_progressz.0f%)r.get_loading_progress)r0r1r2r3progresss rr6r6sKNu%%::';H x.... rcLt||||S)aShow load state of collection or partitions. :param collection_name: The name of collection is loading :type collection_name: str :param partition_names: The names of partitions is loading :type partition_names: str list :return LoadState: The current state of collection or partitions. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> from pymilvus.client.types import LoadState >>> import pandas as pd >>> import random >>> assert utility.load_state("test_load_state") == LoadState.NotExist >>> fields = [ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", DataType.FLOAT_VECTOR, dim=8), ... ] >>> schema = CollectionSchema(fields) >>> collection = Collection("test_load_state", schema) >>> assert utility.load_state("test_load_state") == LoadState.NotLoad >>> data = pd.DataFrame({ ... "film_id" : pd.Series(data=list(range(10, 20)), index=list(range(10))), ... "films": [[random.random() for _ in range(8)] for _ in range (10)], ... }) >>> collection.insert(data) >>> collection.create_index( ... "films", ... {"index_type": "IVF_FLAT", "params": {"nlist": 8}, "metric_type": "L2"}) >>> collection.load(_async=True) >>> assert utility.load_state("test_load_state") == LoadState.Loaded r5)r.get_load_state)r0r1r2r3s r load_stater<s)P 5 ! ! 0 0/[b 0 c ccrc|rt|dkr$t|||St||||S)aa Block until loading is done or Raise Exception after timeout. :param collection_name: The name of collection to wait for loading complete :type collection_name: str :param partition_names: The names of partitions to wait for loading complete :type partition_names: str list :param timeout: The timeout for this method, unit: second :type timeout: int :raises MilvusException: If anything goes wrong. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> _DIM = 128 >>> field_int64 = FieldSchema("int64", DataType.INT64, description="int64", is_primary=True) >>> field_fvec = FieldSchema("float_vector", DataType.FLOAT_VECTOR, dim=_DIM) >>> schema = CollectionSchema(fields=[field_int64, field_fvec]) >>> collection = Collection(name="test_collection", schema=schema) >>> import pandas as pd >>> int64_series = pd.Series(data=list(range(10, 20)), index=list(range(10)))i >>> float_vector_series = [[random.random() for _ in range _DIM] for _ in range (10)] >>> data = pd.DataFrame({"int64" : int64_series, "float_vector": float_vector_series}) >>> collection.insert(data) >>> collection.load() # load collection to memory >>> utility.wait_for_loading_complete("test_collection") rr5)lenr.wait_for_loading_collectionwait_for_loading_partitions)r0r1r3r2s rwait_for_loading_completerA snF dc/22a77u%%AA/[bAccc 5 ! ! = =' >  r index_namecLt||||S)a Show # indexed entities vs. # total entities. :param collection_name: The name of collection is building index :type collection_name: str :param index_name: The name of index is building. Default index_name is to be used if index_name is not specific. :type index_name: str :return dict: Index building progress is a dict contains num of indexed entities and num of total entities. {'total_rows':total_rows,'indexed_rows':indexed_rows} :raises CollectionNotExistException: If collection doesn't exist. :raises IndexNotExistException: If index doesn't exist. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> fields = [ ... FieldSchema("int64", DataType.INT64, is_primary=True, auto_id=True), ... FieldSchema("float_vector", DataType.FLOAT_VECTOR, dim=128), ... ] >>> schema = CollectionSchema(fields, description="test index_building_progress") >>> c = Collection(name="test_index_building_progress", schema=schema) >>> import random >>> vectors = [[random.random() for _ in range(_DIM)] for _ in range(5000)] >>> c.insert([vectors]) >>> c.load() >>> index_params = { ... "metric_type": "L2", ... "index_type": "IVF_FLAT", ... "params": {"nlist": 1024} ... } >>> index = c.create_index( ... field_name="float_vector", ... index_params=index_params, ... index_name="ivf_flat") >>> utility.index_building_progress("test_collection", c.name) )r0rCr3)r.get_index_build_progress)r0rCr2r3s rindex_building_progressrF7s1` 5 ! ! : :'J ;  rcXt||||dS)a" Block until building is done or Raise Exception after timeout. :param collection_name: The name of collection to wait :type collection_name: str :param index_name: The name of index to wait :type index_name: str :param timeout: The timeout for this method, unit: second :type timeout: int :raises CollectionNotExistException: If collection doesn't exist. :raises IndexNotExistException: If index doesn't exist. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> _DIM = 128 >>> field_int64 = FieldSchema("int64", DataType.INT64, description="int64", is_primary=True) >>> field_vector = FieldSchema("float_vector", DataType.FLOAT_VECTOR, dim=_DIM) >>> schema = CollectionSchema(fields=[field_int64, field_vector], description="test") >>> collection = Collection(name="test_collection", schema=schema) >>> import random >>> import numpy as np >>> import pandas as pd >>> vectors = [[random.random() for _ in range(_DIM)] for _ in range(5000)] >>> int64_series = pd.Series(data=list(range(5000, 10000)), index=list(range(5000))) >>> vectors = [[random.random() for _ in range(_DIM)] for _ in range (5000)] >>> data = pd.DataFrame({"int64" : int64_series, "float_vector": vectors}) >>> collection.insert(data) >>> collection.load() # load collection to memory >>> index_param = { >>> "metric_type": "L2", >>> "index_type": "IVF_FLAT", >>> "params": {"nlist": 1024} >>> } >>> collection.create_index("float_vector", index_param) >>> utility.index_building_progress("test_collection", "") >>> utility.loading_progress("test_collection") r5r)r.wait_for_creating_index)r0rCr3r2s r wait_for_index_building_completerIls9^ 5 ! ! 9 9W :    rcJt|||S)a Checks whether a specified collection exists. :param collection_name: The name of collection to check. :type collection_name: str :return bool: Whether the collection exists. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> _DIM = 128 >>> field_int64 = FieldSchema("int64", DataType.INT64, description="int64", is_primary=True) >>> field_vector = FieldSchema("float_vector", DataType.FLOAT_VECTOR, dim=_DIM) >>> schema = CollectionSchema(fields=[field_int64, field_vector], description="test") >>> collection = Collection(name="test_collection", schema=schema) >>> utility.has_collection("test_collection") r5)r.has_collection)r0r2r3s rrKrKs%& 5 ! ! 0 0' 0 R RRrpartition_namereturncLt||||S)aS Checks if a specified partition exists in a collection. :param collection_name: The collection name of partition to check :type collection_name: str :param partition_name: The name of partition to check. :type partition_name: str :return bool: Whether the partition exist. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> _DIM = 128 >>> field_int64 = FieldSchema("int64", DataType.INT64, description="int64", is_primary=True) >>> field_vector = FieldSchema("float_vector", DataType.FLOAT_VECTOR, dim=_DIM) >>> schema = CollectionSchema(fields=[field_int64, field_vector], description="test") >>> collection = Collection(name="test_collection", schema=schema) >>> utility.has_partition("_default") r5)r. has_partition)r0rLr2r3s rrOrOs(6 5 ! ! / /Y` / a aarcJt|||S)a Drop a collection by name :param collection_name: A string representing the collection to be deleted :type collection_name: str :param timeout: 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. :type timeout: float :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> schema = CollectionSchema(fields=[ ... FieldSchema("int64", DataType.INT64, description="int64", is_primary=True), ... FieldSchema("float_vector", DataType.FLOAT_VECTOR, is_primary=False, dim=128), ... ]) >>> collection = Collection(name="drop_collection_test", schema=schema) >>> utility.has_collection("drop_collection_test") >>> True >>> utility.drop_collection("drop_collection_test") >>> utility.has_collection("drop_collection_test") >>> False r5)r.drop_collectionr0r3r2s rrQrQs%. 5 ! ! 1 1/7 1 S SSrold_collection_namenew_collection_name new_db_namecNt|||||S)a Rename a collection to new collection name :param old_collection_name: A string representing old name of the renamed collection :type old_collection_name: str :param new_collection_name: A string representing new name of the renamed collection :type new_collection_name: str :param timeout: 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. :type timeout: float :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> schema = CollectionSchema(fields=[ ... FieldSchema("int64", DataType.INT64, description="int64", is_primary=True), ... FieldSchema("float_vector", DataType.FLOAT_VECTOR, is_primary=False, dim=128), ... ]) >>> collection = Collection(name="old_collection", schema=schema) >>> utility.rename_collection("old_collection", "new_collection") >>> True >>> utility.drop_collection("new_collection") >>> utility.has_collection("new_collection") >>> False )old_namenew_namerUr3)r.rename_collections)rSrTrUr3r2s rrename_collectionrZs6B 5 ! ! 4 4$$ 5  rcHt||S)a Returns a list of all collection names. :param timeout: 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. :type timeout: float :param using: An optional alias for the database host. Default value is "default". :type using: str :return list[str]: List of collection names, return when operation is successful :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> _DIM = 128 >>> field_int64 = FieldSchema("int64", DataType.INT64, description="int64", is_primary=True) >>> field_vector = FieldSchema("float_vector", DataType.FLOAT_VECTOR, dim=_DIM) >>> schema = CollectionSchema(fields=[field_int64, field_vector], description="test") >>> collection = Collection(name="test_collection", schema=schema) >>> utility.list_collections() r5)r.list_collections)r3r2s rr\r\s#. 5 ! ! 2 27 2 C CCr src_node_id dst_node_idssealed_segment_idsc`|g}|g}t||||||S)aDo load balancing operation from source query node to destination query node. :param collection_name: The collection to balance. :type collection_name: str :param src_node_id: The source query node id to balance. :type src_node_id: int :param dst_node_ids: The destination query node ids to balance. :type dst_node_ids: list[int] :param sealed_segment_ids: Sealed segment ids to balance. :type sealed_segment_ids: list[int] :param timeout: The timeout for this method, unit: second :type timeout: int :raises BaseException: If query nodes not exist. :raises BaseException: If sealed segments not exist. :example: >>> from pymilvus import connections, utility >>> >>> connections.connect() >>> >>> src_node_id = 0 >>> dst_node_ids = [1] >>> sealed_segment_ids = [] >>> res = utility.load_balance("test", src_node_id, dst_node_ids, sealed_segment_ids) Nr5)r. load_balance)r0r]r^r_r3r2s rrara1sNL ! 5 ! ! . .l4FPW /  rcJt|||S)a Notifies Proxy to return segments information from query nodes. :param collection_name: A string representing the collection to get segments info. :param timeout: 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. :type timeout: float :return: QuerySegmentInfo: QuerySegmentInfo is the growing segments's information in query cluster. :rtype: QuerySegmentInfo :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> _DIM = 128 >>> field_int64 = FieldSchema("int64", DataType.INT64, description="int64", is_primary=True) >>> field_vector = FieldSchema("float_vector", DataType.FLOAT_VECTOR, dim=_DIM) >>> schema = CollectionSchema(fields=[field_int64, field_vector]) >>> collection = Collection(name="test_get_segment_info", schema=schema) >>> import pandas as pd >>> int64_series = pd.Series(data=list(range(10, 20)), index=list(range(10)))i >>> float_vector_series = [[random.random() for _ in range _DIM] for _ in range (10)] >>> data = pd.DataFrame({"int64" : int64_series, "float_vector": float_vector_series}) >>> collection.insert(data) >>> collection.load() # load collection to memory >>> res = utility.get_query_segment_info("test_get_segment_info") r5)r.get_query_segment_inforRs rrcrc`s'@ 5 ! ! 8 8RY 8 Z ZZrcLt||||S)aSpecify alias for a collection. Alias cannot be duplicated, you can't assign the same alias to different collections. But you can specify multiple aliases for a collection, for example: before create_alias("collection_1", "bob"): aliases of collection_1 are ["tom"] after create_alias("collection_1", "bob"): aliases of collection_1 are ["tom", "bob"] :param alias: The alias of the collection. :type alias: str. :param timeout: 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 :type timeout: float :raises CollectionNotExistException: If the collection does not exist. :raises BaseException: If the alias failed to create. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_create_alias", schema) >>> utility.create_alias(collection.name, "alias") Status(code=0, message='') r5)r. create_aliasr0r*r3r2s rreres(D 5 ! ! . .w . W WWrcJt|||S)aDelete the alias. No need to provide collection name because an alias can only be assigned to one collection and the server knows which collection it belongs. For example: before drop_alias("bob"): aliases of collection_1 are ["tom", "bob"] after drop_alias("bob"): aliases of collection_1 are = ["tom"] :param alias: The alias to drop. :type alias: str :param timeout: 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 :type timeout: float :raises CollectionNotExistException: If the collection does not exist. :raises BaseException: If the alias doesn't exist. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_drop_alias", schema) >>> utility.create_alias(collection.name, "alias") >>> utility.drop_alias("alias") Status(code=0, message='') r5)r. drop_alias)r*r3r2s rrhrhs%> 5 ! ! , ,UG , D DDrcLt||||S)aaChange the alias of a collection to another collection. Raise error if the alias doesn't exist. Alias cannot be duplicated, you can't assign same alias to different collections. This api can change alias owner collection, for example: before alter_alias("collection_2", "bob"): collection_1's aliases = ["bob"] collection_2's aliases = [] after alter_alias("collection_2", "bob"): collection_1's aliases = [] collection_2's aliases = ["bob"] :param collection_name: The collection name to witch this alias is goting to alter. :type collection_name: str. :param alias: The alias of the collection. :type alias: str :param timeout: 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 :type timeout: float :raises CollectionNotExistException: If the collection does not exist. :raises BaseException: If the alias failed to alter. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_alter_alias", schema) >>> utility.alter_alias(collection.name, "alias") if the alias exists, return Status(code=0, message='') otherwise return Status(code=1, message='alias does not exist') r5)r. alter_aliasrfs rrjrjs(R 5 ! ! - -oug - V VVrc^t|}|||}|dS)aReturns alias list of the collection. :return list of str: The collection aliases, returned when the operation succeeds. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> fields = [ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=128) ... ] >>> schema = CollectionSchema(fields) >>> collection = Collection("test_collection_list_aliases", schema) >>> utility.create_alias(collection.name, "tom") >>> utility.list_aliases(collection.name) ['tom'] r5aliases)r.describe_collection)r0r3r2connresps r list_aliasesrps3$ 5 ! !D  # #OW # E ED  ?rfilesc @t|j|||fd|i|S)ado_bulk_insert inserts entities through files, currently supports row-based json file. User need to create the json file with a specified json format which is described in the official user guide. Let's say a collection has two fields: "id" and "vec"(dimension=8), the row-based json format is: {"rows": [ {"id": "0", "vec": [0.190, 0.046, 0.143, 0.972, 0.592, 0.238, 0.266, 0.995]}, {"id": "1", "vec": [0.149, 0.586, 0.012, 0.673, 0.588, 0.917, 0.949, 0.944]}, ...... ] } The json file must be uploaded to root path of MinIO/S3 storage which is accessed by milvus server. For example: the milvus.yml specify the MinIO/S3 storage bucketName as "a-bucket", user can upload his json file to a-bucket/xxx.json, then call do_bulk_insert(files=["a-bucket/xxx.json"]) :param collection_name: the name of the collection :type collection_name: str :param partition_name: the name of the partition :type partition_name: str :param files: related path of the file to be imported, for row-based json file, only allow one file each invocation. :type files: list[str] :param timeout: The timeout for this method, unit: second :type timeout: int :param kwargs: other infos :return: id of the task :rtype: int :raises BaseException: If collection_name doesn't exist. :raises BaseException: If the files input is illegal. :example: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> schema = CollectionSchema([ ... FieldSchema("film_id", DataType.INT64, is_primary=True), ... FieldSchema("films", dtype=DataType.FLOAT_VECTOR, dim=2) ... ]) >>> collection = Collection("test_collection_bulk_insert", schema) >>> task_id = utility.do_bulk_insert(collection_name=collection.name, files=['data.json']) >>> print(task_id) r3)r.do_bulk_insert)r0rqrLr3r2kwargss rrsrs s@x 1?5 ! ! 0  8? CI  rtask_idc <t|j|fd|i|S)aget_bulk_insert_state returns state of a certain task_id :param task_id: the task id returned by bulk_insert :type task_id: int :return: BulkInsertState :rtype: BulkInsertState :example: >>> from pymilvus import connections, utility, BulkInsertState >>> connections.connect() >>> # the id is returned by do_bulk_insert() >>> state = utility.get_bulk_insert_state(task_id=id) >>> if state.state == BulkInsertState.ImportFailed or ... state.state == BulkInsertState.ImportFailedAndCleaned: >>> print("task id:", state.task_id, "failed, reason:", state.failed_reason) r3)r.get_bulk_insert_state)rur3r2rts rrwrwNs-. 8?5 ! ! 7 [ [ [TZ [ [[rlimitc >t|j||fd|i|S)allist_bulk_insert_tasks lists all bulk load tasks :param limit: maximum number of tasks returned, list all tasks if the value is 0, else return the latest tasks :type limit: int :param collection_name: target collection name, list all tasks if the name is empty :type collection_name: str :return: list[BulkInsertState] :rtype: list[BulkInsertState] :example: >>> from pymilvus import connections, utility, BulkInsertState >>> connections.connect() >>> tasks = utility.list_bulk_insert_tasks(collection_name=collection_name) >>> print(tasks) r3)r.list_bulk_insert_tasks)rxr0r3r2rts rrzrzhs=2 9?5 ! ! 8   (/ 39  ruser old_password new_passwordcNt|||||S)a Reset the user & password of the connection. You must provide the original password to check if the operation is valid. Note: after this operation, the connection is also ready to use. :param user: the user of the Milvus connection. :type user: str :param old_password: the original password of the Milvus connection. :type old_password: str :param new_password: the newly password of this user. :type new_password: str :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> utility.reset_password(user, old_password, new_password) >>> users = utility.list_usernames() >>> print(f"users in Milvus: {users}") r5)r.reset_passwordr{r|r}r2r3s rrrs*4 5 ! ! 0 0|\[b 0 c ccrpasswordcLt||||S)aCreate User using the given user and password. :param user: the user name. :type user: str :param password: the password. :type password: str :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> utility.create_user(user, password) >>> connections.connect(user=user, password=password) >>> users = utility.list_usernames() >>> print(f"users in Milvus: {users}") r5)r. create_user)r{rr2r3s rrrs'( 5 ! ! - -dHg - N NNrcNt|||||S)av Update user password using the given user and password. You must provide the original password to check if the operation is valid. Note: after this operation, PyMilvus won't change the related header of this connection. So if you update credential for this connection, the connection may be invalid. :param user: the user name. :type user: str :param old_password: the original password. :type old_password: str :param new_password: the newly password of this user. :type new_password: str :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> utility.update_password(user, old_password, new_password) >>> connections.connect(user=user, password=new_password) >>> users = utility.list_usernames() >>> print(f"users in Milvus: {users}") r5)r.update_passwordrs rrrs*8 5 ! ! 1 1$ l\c 1 d ddrcJt|||S)aMDelete User corresponding to the username. :param user: the user name. :type user: str :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> utility.delete_user(user) >>> users = utility.list_usernames() >>> print(f"users in Milvus: {users}") r5)r. delete_user)r{r2r3s rrrs% 5 ! ! - -dG - D DDrcHt||S)aList all usernames. :return list of str: The usernames in Milvus instances. :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> users = utility.list_usernames() >>> print(f"users in Milvus: {users}") r5)r.list_usernamesr2r3s rrrs# 5 ! ! 0 0 0 A AArinclude_user_infocJt|||S)aiList All Role Info :param include_user_info: whether to obtain the user information associated with roles :type include_user_info: bool :return RoleInfo :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> roles = utility.list_roles() >>> print(f"roles in Milvus: {roles}") r5)r.select_all_role)rr2r3s r list_rolesr& 5 ! ! 1 12CW 1 U UUrusernameinclude_role_infocLt||||S)aList One User Info :param username: user name. :type username: str :param include_role_info: whether to obtain the role information associated with the user :type include_role_info: bool :return UserInfo :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> user = utility.list_user(username, include_role_info) >>> print(f"user info: {user}") r5)r.select_one_user)rrr2r3s r list_userrs)& 5 ! ! 1 1(>> from pymilvus import connections, utility >>> connections.connect() >>> users = utility.list_users(include_role_info) >>> print(f"users info: {users}") r5)r.select_all_user)rr2r3s r list_usersrrrcHt||S)zget the running server's version :returns: server's version :rtype: str :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> utility.get_server_version() >>> "2.2.0" r5)r.get_server_versionrs rrr*s# 5 ! ! 4 4W 4 E EErnamec :t|j||fi|S)a]Create a resource group It will success whether or not the resource group exists. :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> utility.create_resource_group(name) >>> rgs = utility.list_resource_groups() >>> print(f"resource groups in Milvus: {rgs}") )r.create_resource_group)rr2r3rts rrr9s) 8?5 ! ! 7g P P P PPrconfigscHt|||S)aUpdate resource groups. This function updates the resource groups based on the provided configurations. :param configs: A mapping of resource group names to their configurations. :type configs: Mapping[str, ResourceGroupConfig] :param using: The name of the connection to use. Defaults to "default". :type using: (str, optional) :param timeout: The timeout value in seconds. Defaults to None. :type timeout: (float, optional) :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> configs = { ... "resource_group_1": ResourceGroupConfig( ... requests={"node_num": 1}, ... limits={"node_num": 5}, ... transfer_from=[{"resource_group": "resource_group_2"}], ... transfer_to=[{"resource_group": "resource_group_2"}], ... ), ... "resource_group_2": ResourceGroupConfig( ... requests={"node_num": 4}, ... limits={"node_num": 4}, ... transfer_from=[{"resource_group": "__default_resource_group"}], ... transfer_to=[{"resource_group": "resource_group_1"}], ... ), ... } >>> utility.update_resource_groups(configs) )r.update_resource_groups)rr2r3s rrrIs#D 5 ! ! 8 8' J JJrcHt|||S)akDrop a resource group It will success if the resource group is existed and empty, otherwise fail. :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> utility.drop_resource_group(name) >>> rgs = utility.list_resource_groups() >>> print(f"resource groups in Milvus: {rgs}") )r.drop_resource_grouprr2r3s rrrns" 5 ! ! 5 5dG D DDrcHt|||S)aADrop a resource group It will success if the resource group is existed and empty, otherwise fail. :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> rgInfo = utility.list_resource_groups(name) >>> print(f"resource group info: {rgInfo}") )r.describe_resource_grouprs rrr|s" 5 ! ! 9 9$ H HHrcFt||S)a(list all resource group names :return: all resource group names :rtype: list[str] :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> rgs = utility.list_resource_groups() >>> print(f"resource group names: {rgs}") )r.list_resource_groupsrs rrrs  5 ! ! 6 6w ? ??r source_group target_group num_nodescLt|||||S)atransfer num_node from source resource group to target resource_group :param source_group: source resource group name :type source_group: str :param target_group: target resource group name :type target_group: str :param num_nodes: transfer node num :type num_nodes: int :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> rgs = utility.transfer_node(source_group, target_group, num_nodes) )r. transfer_node)rrrr2r3s rrrs'* 5 ! ! / / lIW^ _ __r num_replicascNt||||||S)a[transfer num_replica from source resource group to target resource group :param source_group: source resource group name :type source_group: str :param target_group: target resource group name :type target_group: str :param collection_name: collection name which replica belong to :type collection_name: str :param num_replicas: transfer replica num :type num_replicas: int :example: >>> from pymilvus import connections, utility >>> connections.connect() >>> rgs = utility.transfer_replica(source, target, collection_name, num_replica) )r.transfer_replica)rrr0rr2r3s rrrs/0 5 ! ! 2 2lO\7  rc :t|jdd|i|S)aFlush all collections. All insertions, deletions, and upserts before `flush_all` will be synced. 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. **kwargs (``dict``, optional): * *db*(``string``) database to flush. * *_async*(``bool``) Indicate if invoke asynchronously. Default `False`. Examples: >>> from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, utility >>> 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]]]) >>> utility.flush_all(_async=False) # synchronized flush_all >>> # or use `future` to flush_all asynchronously >>> future = utility.flush_all(_async=True) >>> future.done() # flush_all finished r3)r. flush_all)r2r3rts rrrs*8 ,?5 ! ! + F FG Fv F FFrcDt|S)aGGet the server type. Now, it will return "zilliz" if the connection related to an instance on the zilliz cloud, otherwise "milvus" will be returned. :param using: Alias to the connection. Default connection is used if this is not specified. :type using: str :return: The server type. :rtype: str )r.get_server_type)r2s rrrs 5 ! ! 1 1 3 33rc t|j||fi|}|d}g}|D]G}|C|||j|%|j|kr||jH|S)a|List all indexes of collection. If `field_name` is not specified, return all the indexes of this collection, otherwise this interface will return all indexes on this field of the collection. :param collection_name: The name of collection. :type collection_name: str :param using: Alias to the connection. Default connection is used if this is not specified. :type using: str :param timeout: 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 :type timeout: float/int :param kwargs: * *field_name* (``str``) The name of field. If no field name is specified, all indexes of this collection will be returned. :type kwargs: dict :return: The name list of all indexes. :rtype: str list field_name)r. list_indexesgetappendrCr)r0r2r3rtindexesrindex_name_listindexs rrrs:2oe$$1/7UUfUUGL))JO99  !&&u'7888%%*:j*H*H&&u'7888 r)rNr,)Nr/N)NNr/)rBr/N)rBNr/)r/N)Nr/)NNNr/)rNNr/)r/)Crrrtypingrrrpymilvus.client.typesr r pymilvus.client.utilsr r%r r r rrrpymilvus.exceptionsrrintfloatr(strr.r6r<rArFrIrKboolrOrQrZlistr\rarcrerhrjrprsrwrzrrrrrrrrrrrrrrrrrrrrrrrs 3222222222**********POOOOOKKKKKKKKKKKKKKKKKK//////$$$$$$ Q Q QE QQZH[ Q Q Q QFNNeN5NxPYGZNNNN:OSOO O$)O8@8KOOOO89939HX,>9999@+3++++.-3---- ,0# ,,,d3i(, ,e_ ,,,,b,0# (d(d(dd3i((d (de_ (d(d(d(dZ,0# '''d3i('e_'  ''''X# 2222 2e_ 2222n# 1 1 1 1 e_1   1 1 1 1 hSSCSS(SX/SSSS2# bbbb be_ b  bbbb<TTST8E?TRUTTTT:# &&&&&e_ &  &&&&RDDhuoDSDQUDDDD:)-.2# ,,,,49%,!c+ , e_ ,  ,,,,b $ [ [ [ e_ [  [ [ [ [L $ "X"X"X "Xe_"X  "X"X"X"XJEEcEHUOE3EEEEJ $ )W)W)W )We_)W  )W)W)W)WX#s4%)# >>> 9>SM>e_ >  > >>>>F $\\ \ e_\ \  \\\\6%)#  c]e_    D# dd ddd  d e_ dddd@# OO OO Oe_ OOOO6# ee eee  e e_ eeee> E Ec E# EHUO E E E E B B# BHUO B B B B V V$ Vs VRW V V V V$# ```` `e_ ````, V V$ Vs VRW V V V V F Fc F FSV F F F F CG Q Q  Q Q08 Q Q Q Q$#"K"K S-- ."K "Ke_"K"K"K"KJ E Ec E# EHUO E E E E I I# Ic IQV I I I I @ @ @(5/ @ @ @ @$# `````  ` e_ ````:#     e_ :GGSGxGGGG> 4 43 4 4 4 4#((( (e_((((((r