docstr: collection schema 1: [pk, float_vector]
  data file: .npy files
  Steps:
  1. create collection
  2. import data
  3. if column_based:
    4.1 verify the data entities equal the import data
    4.2 verify search and query successfully
code: def test_float_vector_from_multi_numpy_files(
      self, auto_id, dim, entities
  ):
      """
      collection schema 1: [pk, float_vector]
      data file: .npy files
      Steps:
      1. create collection
      2. import data
      3. if column_based:
        4.1 verify the data entities equal the import data
        4.2 verify search and query successfully
      """
      # NOTE: 128d_1m --> 977MB
      suffix = entity_suffix(entities)
      vec_field = f"vectors_{dim}d_{suffix}"
      self._connect()
      c_name = cf.gen_unique_str("bulk_insert")
      fields = [
          cf.gen_int64_field(name=df.pk_field, is_primary=True),
          cf.gen_float_vec_field(name=vec_field, dim=dim),
      ]
      schema = cf.gen_collection_schema(fields=fields, auto_id=auto_id)
      self.collection_wrap.init_collection(c_name, schema=schema)
      data_fields = [df.pk_field, vec_field]
      # import data
      file_nums = 3
      files = prepare_bulk_insert_numpy_files(
          minio_endpoint=self.minio_endpoint,
          bucket_name=self.bucket_name,
          rows=entities,
          dim=dim,
          data_fields=data_fields,
          file_nums=file_nums,
          force=True,
      )
      log.info(f"files:{files}")
      for i in range(file_nums):
          files = [
              f"{dim}d_{suffix}_{i}/{vec_field}.npy"
          ]  # npy file name shall be the vector field name
          if not auto_id:
              files.append(f"{dim}d_{suffix}_{i}/{df.pk_field}.npy")
          t0 = time.time()
          check_flag = True
          for file in files:
              file_size = (
                  Path(f"{base_dir}/{file}").stat().st_size
                  / 1024
                  / 1024
              )
              if file_size >= 1024:
                  check_flag = False
                  break
  
          task_id, _ = self.utility_wrap.do_bulk_insert(
              collection_name=c_name, files=files
          )
          logging.info(f"bulk insert task ids:{task_id}")
          (
              success,
              states,
          ) = self.utility_wrap.wait_for_bulk_insert_tasks_completed(
              task_ids=[task_id], timeout=180
          )
          tt = time.time() - t0
          log.info(
              f"auto_id:{auto_id}, bulk insert{suffix}-{i} state:{success} in {tt}"
          )
          assert success is check_flag
  
      # TODO: assert num entities
      if success:
          t0 = time.time()
          num_entities = self.collection_wrap.num_entities
          tt = time.time() - t0
          log.info(f" collection entities: {num_entities} in {tt}")
          assert num_entities == entities * file_nums
  
          # verify imported data is available for search
          index_params = ct.default_index
          self.collection_wrap.create_index(
              field_name=df.vec_field, index_params=index_params
          )
          self.collection_wrap.load()
          log.info(f"wait for load finished and be ready for search")
          time.sleep(20)
          loaded_segs = len(
              self.utility_wrap.get_query_segment_info(c_name)[0]
          )
          log.info(f"query seg info: {loaded_segs} segs loaded.")
          search_data = cf.gen_vectors(1, dim)
          search_params = ct.default_search_params
          res, _ = self.collection_wrap.search(
              search_data,
              vec_field,
              param=search_params,
              limit=1,
              check_task=CheckTasks.check_search_results,
              check_items={"nq": 1, "limit": 1},
          )
  
imports: import logging
  import time
  import pytest
  import random
  import numpy
  from pathlib import Path
  from base.client_base import TestcaseBase
  from common import common_func
  from common import common_type
  from common.milvus_sys import MilvusSys
  from common.common_type import CaseLabel, CheckTasks
  from utils.util_k8s import get_pod_ip_name_pairs, get_milvus_instance_name, get_milvus_deploy_tool
  from utils.util_log import test_log
  from common.bulk_insert_data import prepare_bulk_insert_json_files, prepare_bulk_insert_numpy_files, DataField, DataErrorType
label_desc: Use image node_id 1 for calling the TestBulkInsertAdvanced obj's underlying member method code with example usage: obj.test_float_vector_from_multi_numpy_files(auto_id, dim, entities) without return types