def construct_from_dataframe(self, name, dataframe, check_task=None, check_items=None, **kwargs):
func_name = sys._getframe().f_code.co_name
res, is_succ = api_request([Collection.construct_from_dataframe, name, dataframe], **kwargs)
self.collection = res[0] if is_succ else None
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ,
name=name, dataframe=dataframe, **kwargs).run()
return res, check_result
def search(self,
data,
anns_field,
params,
limit,
expr=None,
output_fields=None,
check_task=None,
check_items=None,
**kwargs):
timeout = kwargs.get("timeout", TIMEOUT)
kwargs.update({"timeout": timeout})
func_name = sys._getframe().f_code.co_name
res, succ = api_request([
self.partition.search, data, anns_field, params, limit, expr,
output_fields
], **kwargs)
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ=succ,
data=data,
anns_field=anns_field,
params=params,
limit=limit,
expr=expr,
output_fields=output_fields,
**kwargs).run()
return res, check_result
def search(self,
data,
anns_field,
param,
limit,
expression,
partition_names=None,
output_fields=None,
timeout=None,
check_task=None,
check_items=None,
**kwargs):
func_name = sys._getframe().f_code.co_name
res, check = api_request([
self.collection.search, data, anns_field, param, limit, expression,
partition_names, output_fields, timeout
], **kwargs)
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
check,
data=data,
anns_field=anns_field,
param=param,
limit=limit,
expression=expression,
partition_names=partition_names,
output_fields=output_fields,
timeout=timeout,
**kwargs).run()
return res, check_result
def init_index(self,
collection,
field_name,
index_params,
index_name=None,
check_task=None,
check_items=None,
**kwargs):
timeout = kwargs.get("timeout", TIMEOUT * 2)
index_name = INDEX_NAME if index_name is None else index_name
index_name = kwargs.get("index_name", index_name)
kwargs.update({"timeout": timeout, "index_name": index_name})
""" In order to distinguish the same name of index """
func_name = sys._getframe().f_code.co_name
res, is_succ = api_request(
[Index, collection, field_name, index_params], **kwargs)
self.index = res if is_succ is True else None
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ,
collection=collection,
field_name=field_name,
index_params=index_params,
**kwargs).run()
return res, check_result
def add_connection(self, check_task=None, check_items=None, **kwargs):
func_name = sys._getframe().f_code.co_name
response, is_succ = api_request([self.connection.add_connection],
**kwargs)
check_result = ResponseChecker(response, func_name, check_task,
check_items, is_succ, **kwargs).run()
return response, check_result
def query(self,
expr,
output_fields=None,
partition_names=None,
timeout=None,
check_task=None,
check_items=None,
**kwargs):
# time.sleep(5)
timeout = TIMEOUT if timeout is None else timeout
func_name = sys._getframe().f_code.co_name
res, check = api_request([
self.collection.query, expr, output_fields, partition_names,
timeout
])
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
check,
expression=expr,
partition_names=partition_names,
output_fields=output_fields,
timeout=timeout,
**kwargs).run()
return res, check_result
def search(self,
data,
anns_field,
param,
limit,
expr=None,
partition_names=None,
output_fields=None,
timeout=None,
round_decimal=-1,
check_task=None,
check_items=None,
**kwargs):
timeout = TIMEOUT if timeout is None else timeout
func_name = sys._getframe().f_code.co_name
res, check = api_request([
self.collection.search, data, anns_field, param, limit, expr,
partition_names, output_fields, timeout, round_decimal
], **kwargs)
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
check,
data=data,
anns_field=anns_field,
param=param,
limit=limit,
expr=expr,
partition_names=partition_names,
output_fields=output_fields,
timeout=timeout,
**kwargs).run()
return res, check_result
def insert(self, data, partition_name=None, check_task=None, check_items=None, **kwargs):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.collection.insert, data, partition_name], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items, check,
dat=data, partition_name=partition_name,
**kwargs).run()
return res, check_result
def init_collection(self,
name,
schema=None,
using="default",
shards_num=2,
check_task=None,
check_items=None,
**kwargs):
consistency_level = kwargs.get("consistency_level", CONSISTENCY_STRONG)
kwargs.update({"consistency_level": consistency_level})
""" In order to distinguish the same name of collection """
func_name = sys._getframe().f_code.co_name
res, is_succ = api_request(
[Collection, name, schema, using, shards_num], **kwargs)
self.collection = res if is_succ else None
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ,
name=name,
schema=schema,
using=using,
shards_num=shards_num,
**kwargs).run()
return res, check_result
def init_collection(self, name, schema=None, check_task=None, check_items=None, **kwargs):
""" In order to distinguish the same name of collection """
func_name = sys._getframe().f_code.co_name
res, is_succ = api_request([Collection, name, schema], **kwargs)
self.collection = res if is_succ else None
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ,
name=name, schema=schema, **kwargs).run()
return res, check_result
def drop(self, check_task=None, check_items=None, **kwargs):
timeout = kwargs.get("timeout", TIMEOUT)
kwargs.update({"timeout": timeout})
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.collection.drop], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items, check, **kwargs).run()
return res, check_result
def create_index(self, field_name, index_params, check_task=None, check_items=None, **kwargs):
timeout = kwargs.get("timeout", TIMEOUT * 2)
kwargs.update({"timeout": timeout})
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.collection.create_index, field_name, index_params], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items, check,
field_name=field_name, index_params=index_params, **kwargs).run()
return res, check_result
def release(self, check_task=None, check_items=None, **kwargs):
func_name = sys._getframe().f_code.co_name
res, succ = api_request([self.partition.release], **kwargs)
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ=succ,
**kwargs).run()
return res, check_result
def disconnect(self, alias, check_task=None, check_items=None):
func_name = sys._getframe().f_code.co_name
response, is_succ = api_request([self.connection.disconnect, alias])
check_result = ResponseChecker(response,
func_name,
check_task,
check_items,
is_succ,
alias=alias).run()
return response, check_result
def partition(self, partition_name, check_task=None, check_items=None):
func_name = sys._getframe().f_code.co_name
res, succ = api_request([self.collection.partition, partition_name])
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
succ,
partition_name=partition_name).run()
return res, check_result
def drop(self, check_task=None, check_items=None, **kwargs):
log.info("Dropping collection")
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.collection.drop], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items,
check, **kwargs).run()
if check_result:
log.info("Dropped collection")
else:
log.info("Dropping collection failed")
return res, check_result
def compact(self,
timeout=None,
check_task=None,
check_items=None,
**kwargs):
timeout = TIMEOUT if timeout is None else timeout
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.collection.compact, timeout], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items,
check, **kwargs).run()
return res, check_result
def release(self, check_task=None, check_items=None, **kwargs):
timeout = kwargs.get("timeout", TIMEOUT)
kwargs.update({"timeout": timeout})
func_name = sys._getframe().f_code.co_name
res, succ = api_request([self.partition.release], **kwargs)
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ=succ,
**kwargs).run()
return res, check_result
def has_connection(self,
alias=DefaultConfig.DEFAULT_USING,
check_task=None,
check_items=None):
func_name = sys._getframe().f_code.co_name
response, succ = api_request([self.connection.has_connection, alias])
check_result = ResponseChecker(response,
func_name,
check_task,
check_items,
succ,
alias=alias).run()
return response, check_result
def has_index(self,
index_name=None,
check_task=None,
check_items=None,
**kwargs):
index_name = INDEX_NAME if index_name is None else index_name
index_name = kwargs.get("index_name", index_name)
kwargs.update({"index_name": index_name})
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.collection.has_index], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items,
check, **kwargs).run()
return res, check_result
def create_partition(self,
partition_name,
check_task=None,
check_items=None,
description=""):
func_name = sys._getframe().f_code.co_name
res, check = api_request(
[self.collection.create_partition, partition_name, description])
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
check,
partition_name=partition_name).run()
return res, check_result
def list_collections(self,
timeout=None,
using="default",
check_task=None,
check_items=None):
func_name = sys._getframe().f_code.co_name
res, is_succ = api_request([self.ut.list_collections, timeout, using])
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ,
timeout=timeout,
using=using).run()
return res, check_result
def drop(self,
index_name=None,
check_task=None,
check_items=None,
**kwargs):
timeout = kwargs.get("timeout", TIMEOUT)
index_name = INDEX_NAME if index_name is None else index_name
index_name = kwargs.get("index_name", index_name)
kwargs.update({"timeout": timeout, "index_name": index_name})
func_name = sys._getframe().f_code.co_name
res, is_succ = api_request([self.index.drop], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items,
is_succ, **kwargs).run()
return res, check_result
def init_partition(self,
collection,
name,
description="",
check_task=None,
check_items=None,
**kwargs):
""" In order to distinguish the same name of partition """
func_name = sys._getframe().f_code.co_name
response, is_succ = api_request(
[Partition, collection, name, description], **kwargs)
self.partition = response if is_succ is True else None
check_result = ResponseChecker(response, func_name, check_task,
check_items, is_succ, **kwargs).run()
return response, check_result
def load(self,
partition_names=None,
check_task=None,
check_items=None,
**kwargs):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.collection.load, partition_names],
**kwargs)
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
check,
partition_names=partition_names,
**kwargs).run()
return res, check_result
def has_collection(self,
collection_name,
using="default",
check_task=None,
check_items=None):
func_name = sys._getframe().f_code.co_name
res, is_succ = api_request(
[self.ut.has_collection, collection_name, using])
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ,
collection_name=collection_name,
using=using).run()
return res, check_result
def drop_alias(self,
alias,
timeout=None,
using="default",
check_task=None,
check_items=None):
timeout = TIMEOUT if timeout is None else timeout
func_name = sys._getframe().f_code.co_name
res, is_succ = api_request([self.ut.drop_alias, alias, timeout, using])
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ,
timeout=timeout,
using=using).run()
return res, check_result
def create_index(self,
field_name,
index_params,
check_task=None,
check_items=None,
**kwargs):
func_name = sys._getframe().f_code.co_name
res, check = api_request(
[self.collection.create_index, field_name, index_params], **kwargs)
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
check,
field_name=field_name,
index_params=index_params,
**kwargs).run()
return res, check_result
def get_bulk_load_state(self,
task_id,
timeout=None,
using="default",
check_task=None,
check_items=None,
**kwargs):
func_name = sys._getframe().f_code.co_name
res, is_succ = api_request(
[self.ut.get_bulk_load_state, task_id, timeout, using], **kwargs)
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ,
task_id=task_id,
using=using).run()
return res, check_result
def load(self,
replica_number=NaN,
timeout=None,
check_task=None,
check_items=None,
**kwargs):
timeout = TIMEOUT if timeout is None else timeout
replica_number = param_info.param_replica_num if replica_number is NaN else replica_number
func_name = sys._getframe().f_code.co_name
res, succ = api_request([self.partition.load, replica_number, timeout],
**kwargs)
check_result = ResponseChecker(res,
func_name,
check_task,
check_items,
is_succ=succ,
**kwargs).run()
return res, check_result
