vectordb-bench 0.0.20__tar.gz → 0.0.21__tar.gz

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: vectordb-bench
-Version: 0.0.20
+Version: 0.0.21
 Summary: VectorDBBench is not just an offering of benchmark results for mainstream vector databases and cloud services, it's your go-to tool for the ultimate performance and cost-effectiveness comparison. Designed with ease-of-use in mind, VectorDBBench is devised to help users, even non-professionals, reproduce results or test new systems, making the hunt for the optimal choice amongst a plethora of cloud services and open-source vector databases a breeze.
 Author-email: XuanYang-cn <xuan.yang@zilliz.com>
 Project-URL: repository, https://github.com/zilliztech/VectorDBBench

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/pyproject.toml

@@ -133,6 +133,7 @@ lint.ignore = [
     "RUF017",
     "C416",
     "PLW0603",
+    "COM812",
 ]
 
 # Allow autofix for all enabled rules (when `--fix`) is provided.

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/assembler.py

@@ -53,8 +53,8 @@ class Assembler:
             _ = k.init_cls
 
         # sort by dataset size
-        for k, _ in db2runner:
-            db2runner[k].sort(key=lambda x: x.ca.dataset.data.size)
+        for _, runner in db2runner.items():
+            runner.sort(key=lambda x: x.ca.dataset.data.size)
 
         all_runners = []
         all_runners.extend(load_runners)

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/__init__.py

@@ -42,7 +42,7 @@ class DB(Enum):
     AliyunOpenSearch = "AliyunOpenSearch"
 
     @property
-    def init_cls(self) -> type[VectorDB]:  # noqa: PLR0911, PLR0912
+    def init_cls(self) -> type[VectorDB]:  # noqa: PLR0911, PLR0912, C901
         """Import while in use"""
         if self == DB.Milvus:
             from .milvus.milvus import Milvus
@@ -129,11 +129,16 @@ class DB(Enum):
 
             return AliyunOpenSearch
 
+        if self == DB.Test:
+            from .test.test import Test
+
+            return Test
+
         msg = f"Unknown DB: {self.name}"
         raise ValueError(msg)
 
     @property
-    def config_cls(self) -> type[DBConfig]:  # noqa: PLR0911, PLR0912
+    def config_cls(self) -> type[DBConfig]:  # noqa: PLR0911, PLR0912, C901
         """Import while in use"""
         if self == DB.Milvus:
             from .milvus.config import MilvusConfig
@@ -220,6 +225,11 @@ class DB(Enum):
 
             return AliyunOpenSearchConfig
 
+        if self == DB.Test:
+            from .test.config import TestConfig
+
+            return TestConfig
+
         msg = f"Unknown DB: {self.name}"
         raise ValueError(msg)
 

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/aliyun_opensearch/aliyun_opensearch.py

@@ -325,10 +325,7 @@ class AliyunOpenSearch(VectorDB):
 
         return False
 
-    def optimize(self):
-        pass
-
-    def optimize_with_size(self, data_size: int):
+    def optimize(self, data_size: int):
         log.info(f"optimize count: {data_size}")
         retry_times = 0
         while True:
@@ -340,6 +337,3 @@ class AliyunOpenSearch(VectorDB):
             if total_count == data_size:
                 log.info("optimize table finish.")
                 return
-
-    def ready_to_load(self):
-        """ready_to_load will be called before load in load cases."""

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/alloydb/alloydb.py

@@ -149,10 +149,7 @@ class AlloyDB(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/api.py

@@ -137,6 +137,13 @@ class VectorDB(ABC):
     @contextmanager
     def init(self) -> None:
         """create and destory connections to database.
+        Why contextmanager:
+
+            In multiprocessing search tasks, vectordbbench might init
+            totally hundreds of thousands of connections with DB server.
+
+            Too many connections may drain local FDs or server connection resources.
+            If the DB client doesn't have `close()` method, just set the object to None.
 
         Examples:
             >>> with self.init():
@@ -187,9 +194,8 @@ class VectorDB(ABC):
         """
         raise NotImplementedError
 
-    # TODO: remove
     @abstractmethod
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         """optimize will be called between insertion and search in performance cases.
 
         Should be blocked until the vectorDB is ready to be tested on
@@ -199,16 +205,3 @@ class VectorDB(ABC):
         Optimize's execution time is limited, the limited time is based on cases.
         """
         raise NotImplementedError
-
-    def optimize_with_size(self, data_size: int):
-        self.optimize()
-
-    # TODO: remove
-    @abstractmethod
-    def ready_to_load(self):
-        """ready_to_load will be called before load in load cases.
-
-        Should be blocked until the vectorDB is ready to be tested on
-        heavy load cases.
-        """
-        raise NotImplementedError

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/aws_opensearch/aws_opensearch.py

@@ -145,15 +145,15 @@ class AWSOpenSearch(VectorDB):
                 docvalue_fields=[self.id_col_name],
                 stored_fields="_none_",
             )
-            log.info(f'Search took: {resp["took"]}')
-            log.info(f'Search shards: {resp["_shards"]}')
-            log.info(f'Search hits total: {resp["hits"]["total"]}')
+            log.info(f"Search took: {resp['took']}")
+            log.info(f"Search shards: {resp['_shards']}")
+            log.info(f"Search hits total: {resp['hits']['total']}")
             return [int(h["fields"][self.id_col_name][0]) for h in resp["hits"]["hits"]]
         except Exception as e:
             log.warning(f"Failed to search: {self.index_name} error: {e!s}")
             raise e from None
 
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         """optimize will be called between insertion and search in performance cases."""
         # Call refresh first to ensure that all segments are created
         self._refresh_index()
@@ -194,6 +194,3 @@ class AWSOpenSearch(VectorDB):
             log.info("Calling warmup API to load graphs into memory")
             warmup_endpoint = f"/_plugins/_knn/warmup/{self.index_name}"
             self.client.transport.perform_request("GET", warmup_endpoint)
-
-    def ready_to_load(self):
-        """ready_to_load will be called before load in load cases."""

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/chroma/chroma.py

@@ -57,10 +57,7 @@ class ChromaClient(VectorDB):
     def ready_to_search(self) -> bool:
         pass
 
-    def ready_to_load(self) -> bool:
-        pass
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/elastic_cloud/elastic_cloud.py

@@ -143,7 +143,7 @@ class ElasticCloud(VectorDB):
             log.warning(f"Failed to search: {self.indice} error: {e!s}")
             raise e from None
 
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         """optimize will be called between insertion and search in performance cases."""
         assert self.client is not None, "should self.init() first"
         self.client.indices.refresh(index=self.indice)
@@ -158,6 +158,3 @@ class ElasticCloud(VectorDB):
             task_status = self.client.tasks.get(task_id=force_merge_task_id)
             if task_status["completed"]:
                 return
-
-    def ready_to_load(self):
-        """ready_to_load will be called before load in load cases."""

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/memorydb/cli.py

@@ -43,8 +43,8 @@ class MemoryDBTypedDict(TypedDict):
             show_default=True,
             default=False,
             help=(
-                "Cluster Mode Disabled (CMD), use this flag when testing locally on a single node instance.",
-                " In production, MemoryDB only supports cluster mode (CME)",
+                "Cluster Mode Disabled (CMD), use this flag when testing locally on a single node instance."
+                " In production, MemoryDB only supports cluster mode (CME)"
             ),
         ),
     ]

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/memorydb/memorydb.py

@@ -157,17 +157,14 @@ class MemoryDB(VectorDB):
         self.conn = self.get_client()
         search_param = self.case_config.search_param()
         if search_param["ef_runtime"]:
-            self.ef_runtime_str = f'EF_RUNTIME {search_param["ef_runtime"]}'
+            self.ef_runtime_str = f"EF_RUNTIME {search_param['ef_runtime']}"
         else:
             self.ef_runtime_str = ""
         yield
         self.conn.close()
         self.conn = None
 
-    def ready_to_load(self) -> bool:
-        pass
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def insert_embeddings(

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/milvus/milvus.py

@@ -138,26 +138,7 @@ class Milvus(VectorDB):
             log.warning(f"{self.name} optimize error: {e}")
             raise e from None
 
-    def ready_to_load(self):
-        assert self.col, "Please call self.init() before"
-        self._pre_load(self.col)
-
-    def _pre_load(self, coll: Collection):
-        try:
-            if not coll.has_index(index_name=self._index_name):
-                log.info(f"{self.name} create index")
-                coll.create_index(
-                    self._vector_field,
-                    self.case_config.index_param(),
-                    index_name=self._index_name,
-                )
-            coll.load()
-            log.info(f"{self.name} load")
-        except Exception as e:
-            log.warning(f"{self.name} pre load error: {e}")
-            raise e from None
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         assert self.col, "Please call self.init() before"
         self._optimize()
 

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/pgdiskann/pgdiskann.py

@@ -143,10 +143,7 @@ class PgDiskANN(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/pgvecto_rs/pgvecto_rs.py

@@ -153,10 +153,7 @@ class PgVectoRS(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):
@@ -200,10 +197,7 @@ class PgVectoRS(VectorDB):
             self.cursor.execute(index_create_sql)
             self.conn.commit()
         except Exception as e:
-            log.warning(
-                f"Failed to create pgvecto.rs index {self._index_name} \
-                    at table {self.table_name} error: {e}",
-            )
+            log.warning(f"Failed to create pgvecto.rs index {self._index_name} at table {self.table_name} error: {e}")
             raise e from None
 
     def _create_table(self, dim: int):
@@ -258,9 +252,7 @@ class PgVectoRS(VectorDB):
 
             return len(metadata), None
         except Exception as e:
-            log.warning(
-                f"Failed to insert data into pgvecto.rs table ({self.table_name}), error: {e}",
-            )
+            log.warning(f"Failed to insert data into pgvecto.rs table ({self.table_name}), error: {e}")
             return 0, e
 
     def search_embedding(

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/pgvector/pgvector.py

@@ -228,10 +228,7 @@ class PgVector(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):
@@ -415,9 +412,7 @@ class PgVector(VectorDB):
 
             return len(metadata), None
         except Exception as e:
-            log.warning(
-                f"Failed to insert data into pgvector table ({self.table_name}), error: {e}",
-            )
+            log.warning(f"Failed to insert data into pgvector table ({self.table_name}), error: {e}")
             return 0, e
 
     def search_embedding(

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/pgvectorscale/pgvectorscale.py

@@ -143,10 +143,7 @@ class PgVectorScale(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):
@@ -255,9 +252,7 @@ class PgVectorScale(VectorDB):
 
             return len(metadata), None
         except Exception as e:
-            log.warning(
-                f"Failed to insert data into pgvector table ({self.table_name}), error: {e}",
-            )
+            log.warning(f"Failed to insert data into pgvector table ({self.table_name}), error: {e}")
             return 0, e
 
     def search_embedding(

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/pinecone/pinecone.py

@@ -59,10 +59,7 @@ class Pinecone(VectorDB):
         self.index = pc.Index(self.index_name)
         yield
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/qdrant_cloud/qdrant_cloud.py

@@ -62,10 +62,7 @@ class QdrantCloud(VectorDB):
         self.qdrant_client = None
         del self.qdrant_client
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         assert self.qdrant_client, "Please call self.init() before"
         # wait for vectors to be fully indexed
         try:
@@ -76,8 +73,8 @@ class QdrantCloud(VectorDB):
                     continue
                 if info.status == CollectionStatus.GREEN:
                     msg = (
-                        f"Stored vectors: {info.vectors_count}, Indexed vectors: {info.indexed_vectors_count}, ",
-                        f"Collection status: {info.indexed_vectors_count}",
+                        f"Stored vectors: {info.vectors_count}, Indexed vectors: {info.indexed_vectors_count}, "
+                        f"Collection status: {info.indexed_vectors_count}"
                     )
                     log.info(msg)
                     return

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/redis/redis.py

@@ -95,10 +95,7 @@ class Redis(VectorDB):
     def ready_to_search(self) -> bool:
         """Check if the database is ready to search."""
 
-    def ready_to_load(self) -> bool:
-        pass
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/test/cli.py

@@ -17,7 +17,7 @@ class TestTypedDict(CommonTypedDict): ...
 @click_parameter_decorators_from_typed_dict(TestTypedDict)
 def Test(**parameters: Unpack[TestTypedDict]):
     run(
-        db=DB.NewClient,
+        db=DB.Test,
         db_config=TestConfig(db_label=parameters["db_label"]),
         db_case_config=TestIndexConfig(),
         **parameters,

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/test/test.py

@@ -33,10 +33,7 @@ class Test(VectorDB):
 
         yield
 
-    def ready_to_load(self) -> bool:
-        return True
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/clients/weaviate_cloud/weaviate_cloud.py

@@ -67,10 +67,7 @@ class WeaviateCloud(VectorDB):
         self.client = None
         del self.client
 
-    def ready_to_load(self):
-        """Should call insert first, do nothing"""
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         assert self.client.schema.exists(self.collection_name)
         self.client.schema.update_config(
             self.collection_name,

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/data_source.py

@@ -63,9 +63,7 @@ class AliyunOSSReader(DatasetReader):
         # check size equal
         remote_size, local_size = info.content_length, local.stat().st_size
         if remote_size != local_size:
-            log.info(
-                f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]",
-            )
+            log.info(f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]")
             return False
 
         return True
@@ -89,9 +87,7 @@ class AliyunOSSReader(DatasetReader):
                 local_file = local_ds_root.joinpath(file)
 
                 if (not local_file.exists()) or (not self.validate_file(remote_file, local_file)):
-                    log.info(
-                        f"local file: {local_file} not match with remote: {remote_file}; add to downloading list",
-                    )
+                    log.info(f"local file: {local_file} not match with remote: {remote_file}; add to downloading list")
                     downloads.append((remote_file, local_file))
 
         if len(downloads) == 0:
@@ -135,9 +131,7 @@ class AwsS3Reader(DatasetReader):
                 local_file = local_ds_root.joinpath(file)
 
                 if (not local_file.exists()) or (not self.validate_file(remote_file, local_file)):
-                    log.info(
-                        f"local file: {local_file} not match with remote: {remote_file}; add to downloading list",
-                    )
+                    log.info(f"local file: {local_file} not match with remote: {remote_file}; add to downloading list")
                     downloads.append(remote_file)
 
         if len(downloads) == 0:
@@ -157,9 +151,7 @@ class AwsS3Reader(DatasetReader):
         # check size equal
         remote_size, local_size = info.get("size"), local.stat().st_size
         if remote_size != local_size:
-            log.info(
-                f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]",
-            )
+            log.info(f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]")
             return False
 
         return True

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/runner/mp_runner.py

@@ -79,14 +79,14 @@ class MultiProcessingSearchRunner:
 
                 if count % 500 == 0:
                     log.debug(
-                        f"({mp.current_process().name:16}) ",
-                        f"search_count: {count}, latest_latency={time.perf_counter()-s}",
+                        f"({mp.current_process().name:16}) "
+                        f"search_count: {count}, latest_latency={time.perf_counter()-s}"
                     )
 
         total_dur = round(time.perf_counter() - start_time, 4)
         log.info(
             f"{mp.current_process().name:16} search {self.duration}s: "
-            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}",
+            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}"
         )
 
         return (count, total_dur, latencies)
@@ -94,9 +94,7 @@ class MultiProcessingSearchRunner:
     @staticmethod
     def get_mp_context():
         mp_start_method = "spawn"
-        log.debug(
-            f"MultiProcessingSearchRunner get multiprocessing start method: {mp_start_method}",
-        )
+        log.debug(f"MultiProcessingSearchRunner get multiprocessing start method: {mp_start_method}")
         return mp.get_context(mp_start_method)
 
     def _run_all_concurrencies_mem_efficient(self):
@@ -113,9 +111,7 @@ class MultiProcessingSearchRunner:
                         mp_context=self.get_mp_context(),
                         max_workers=conc,
                     ) as executor:
-                        log.info(
-                            f"Start search {self.duration}s in concurrency {conc}, filters: {self.filters}",
-                        )
+                        log.info(f"Start search {self.duration}s in concurrency {conc}, filters: {self.filters}")
                         future_iter = [executor.submit(self.search, self.test_data, q, cond) for i in range(conc)]
                         # Sync all processes
                         while q.qsize() < conc:
@@ -124,9 +120,7 @@ class MultiProcessingSearchRunner:
 
                         with cond:
                             cond.notify_all()
-                            log.info(
-                                f"Syncing all process and start concurrency search, concurrency={conc}",
-                            )
+                            log.info(f"Syncing all process and start concurrency search, concurrency={conc}")
 
                         start = time.perf_counter()
                         all_count = sum([r.result()[0] for r in future_iter])
@@ -140,18 +134,14 @@ class MultiProcessingSearchRunner:
                         conc_qps_list.append(qps)
                         conc_latency_p99_list.append(latency_p99)
                         conc_latency_avg_list.append(latency_avg)
-                        log.info(
-                            f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}",
-                        )
+                        log.info(f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}")
 
                 if qps > max_qps:
                     max_qps = qps
-                    log.info(
-                        f"Update largest qps with concurrency {conc}: current max_qps={max_qps}",
-                    )
+                    log.info(f"Update largest qps with concurrency {conc}: current max_qps={max_qps}")
         except Exception as e:
             log.warning(
-                f"Fail to search all concurrencies: {self.concurrencies}, max_qps before failure={max_qps}, reason={e}",
+                f"Fail to search, concurrencies: {self.concurrencies}, max_qps before failure={max_qps}, reason={e}"
             )
             traceback.print_exc()
 
@@ -193,9 +183,7 @@ class MultiProcessingSearchRunner:
                         mp_context=self.get_mp_context(),
                         max_workers=conc,
                     ) as executor:
-                        log.info(
-                            f"Start search_by_dur {duration}s in concurrency {conc}, filters: {self.filters}",
-                        )
+                        log.info(f"Start search_by_dur {duration}s in concurrency {conc}, filters: {self.filters}")
                         future_iter = [
                             executor.submit(self.search_by_dur, duration, self.test_data, q, cond) for i in range(conc)
                         ]
@@ -206,24 +194,18 @@ class MultiProcessingSearchRunner:
 
                         with cond:
                             cond.notify_all()
-                            log.info(
-                                f"Syncing all process and start concurrency search, concurrency={conc}",
-                            )
+                            log.info(f"Syncing all process and start concurrency search, concurrency={conc}")
 
                         start = time.perf_counter()
                         all_count = sum([r.result() for r in future_iter])
                         cost = time.perf_counter() - start
 
                         qps = round(all_count / cost, 4)
-                        log.info(
-                            f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}",
-                        )
+                        log.info(f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}")
 
                 if qps > max_qps:
                     max_qps = qps
-                    log.info(
-                        f"Update largest qps with concurrency {conc}: current max_qps={max_qps}",
-                    )
+                    log.info(f"Update largest qps with concurrency {conc}: current max_qps={max_qps}")
         except Exception as e:
             log.warning(
                 f"Fail to search all concurrencies: {self.concurrencies}, max_qps before failure={max_qps}, reason={e}",
@@ -275,14 +257,14 @@ class MultiProcessingSearchRunner:
 
                 if count % 500 == 0:
                     log.debug(
-                        f"({mp.current_process().name:16}) search_count: {count}, ",
-                        f"latest_latency={time.perf_counter()-s}",
+                        f"({mp.current_process().name:16}) search_count: {count}, "
+                        f"latest_latency={time.perf_counter()-s}"
                     )
 
         total_dur = round(time.perf_counter() - start_time, 4)
         log.debug(
             f"{mp.current_process().name:16} search {self.duration}s: "
-            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}",
+            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}"
         )
 
         return count

{vectordb_bench-0.0.20 → vectordb_bench-0.0.21}/vectordb_bench/backend/runner/rate_runner.py

@@ -73,14 +73,14 @@ class RatedMultiThreadingInsertRunner:
 
                         if len(not_done) > 0:
                             log.warning(
-                                f"Failed to finish all tasks in 1s, [{len(not_done)}/{len(executing_futures)}] ",
-                                f"tasks are not done, waited={wait_interval:.2f}, trying to wait in the next round",
+                                f"Failed to finish all tasks in 1s, [{len(not_done)}/{len(executing_futures)}] "
+                                f"tasks are not done, waited={wait_interval:.2f}, trying to wait in the next round"
                             )
                             executing_futures = list(not_done)
                         else:
                             log.debug(
-                                f"Finished {len(executing_futures)} insert-{config.NUM_PER_BATCH} ",
-                                f"task in 1s, wait_interval={wait_interval:.2f}",
+                                f"Finished {len(executing_futures)} insert-{config.NUM_PER_BATCH} "
+                                f"task in 1s, wait_interval={wait_interval:.2f}"
                             )
                             executing_futures = []
                     except Exception as e: