vectordb-bench 0.0.16__py3-none-any.whl → 0.0.17__py3-none-any.whl

vectordb_bench/__init__.py

@@ -17,7 +17,7 @@ class config:
 
     DEFAULT_DATASET_URL = env.str("DEFAULT_DATASET_URL", AWS_S3_URL)
     DATASET_LOCAL_DIR = env.path("DATASET_LOCAL_DIR", "/tmp/vectordb_bench/dataset")
-    NUM_PER_BATCH = env.int("NUM_PER_BATCH", 5000)
+    NUM_PER_BATCH = env.int("NUM_PER_BATCH", 100)
 
     DROP_OLD = env.bool("DROP_OLD", True)
     USE_SHUFFLED_DATA = env.bool("USE_SHUFFLED_DATA", True)

vectordb_bench/backend/clients/milvus/milvus.py

@@ -66,7 +66,8 @@ class Milvus(VectorDB):
                 self.case_config.index_param(),
                 index_name=self._index_name,
             )
-            #  self._pre_load(coll)
+            if kwargs.get("pre_load") is True:
+                self._pre_load(col)
 
         connections.disconnect("default")
 
@@ -92,7 +93,7 @@ class Milvus(VectorDB):
         self._post_insert()
         log.info(f"{self.name} optimizing before search")
         try:
-            self.col.load()
+            self.col.load(refresh=True)
         except Exception as e:
             log.warning(f"{self.name} optimize error: {e}")
             raise e from None

vectordb_bench/backend/dataset.py

@@ -57,11 +57,11 @@ class CustomDataset(BaseDataset):
     dir: str
     file_num: int
     isCustom: bool = True
-    
+
     @validator("size")
     def verify_size(cls, v):
         return v
-    
+
     @property
     def label(self) -> str:
         return "Custom"
@@ -73,7 +73,8 @@ class CustomDataset(BaseDataset):
     @property
     def file_count(self) -> int:
         return self.file_num
-    
+
+
 class LAION(BaseDataset):
     name: str = "LAION"
     dim: int = 768
@@ -242,13 +243,15 @@ class DataSetIterator:
         self._cur = None
         self._sub_idx = [0 for i in range(len(self._ds.train_files))] # iter num for each file
 
+    def __iter__(self):
+        return self
+
     def _get_iter(self, file_name: str):
         p = pathlib.Path(self._ds.data_dir, file_name)
         log.info(f"Get iterator for {p.name}")
         if not p.exists():
             raise IndexError(f"No such file {p}")
-            log.warning(f"No such file: {p}")
-        return ParquetFile(p).iter_batches(config.NUM_PER_BATCH)
+        return ParquetFile(p, memory_map=True, pre_buffer=True).iter_batches(config.NUM_PER_BATCH)
 
     def __next__(self) -> pd.DataFrame:
         """return the data in the next file of the training list"""

vectordb_bench/backend/runner/mp_runner.py

@@ -64,7 +64,7 @@ class MultiProcessingSearchRunner:
                     log.warning(f"VectorDB search_embedding error: {e}")
                     traceback.print_exc(chain=True)
                     raise e from None
-                
+
                 latencies.append(time.perf_counter() - s)
                 count += 1
                 # loop through the test data
@@ -87,11 +87,14 @@ class MultiProcessingSearchRunner:
         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) -> float:
+
+
+    def _run_all_concurrencies_mem_efficient(self):
         max_qps = 0
         conc_num_list = []
         conc_qps_list = []
         conc_latency_p99_list = []
+        conc_latency_avg_list = []
         try:
             for conc in self.concurrencies:
                 with mp.Manager() as m:
@@ -111,13 +114,15 @@ class MultiProcessingSearchRunner:
                         start = time.perf_counter()
                         all_count = sum([r.result()[0] for r in future_iter])
                         latencies = sum([r.result()[2] for r in future_iter], start=[])
-                        latency_p99 = np.percentile(latencies, 0.99)
+                        latency_p99 = np.percentile(latencies, 99)
+                        latency_avg = np.mean(latencies)
                         cost = time.perf_counter() - start
 
                         qps = round(all_count / cost, 4)
                         conc_num_list.append(conc)
                         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}")
 
                 if qps > max_qps:
@@ -134,7 +139,7 @@ class MultiProcessingSearchRunner:
         finally:
             self.stop()
 
-        return max_qps, conc_num_list, conc_qps_list, conc_latency_p99_list
+        return max_qps, conc_num_list, conc_qps_list, conc_latency_p99_list, conc_latency_avg_list
 
     def run(self) -> float:
         """
@@ -145,3 +150,88 @@ class MultiProcessingSearchRunner:
 
     def stop(self) -> None:
         pass
+
+    def run_by_dur(self, duration: int) -> float:
+        return self._run_by_dur(duration)
+
+    def _run_by_dur(self, duration: int) -> float:
+        max_qps = 0
+        try:
+            for conc in self.concurrencies:
+                with mp.Manager() as m:
+                    q, cond = m.Queue(), m.Condition()
+                    with concurrent.futures.ProcessPoolExecutor(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}")
+                        future_iter = [executor.submit(self.search_by_dur, duration, self.test_data, q, cond) for i in range(conc)]
+                        # Sync all processes
+                        while q.qsize() < conc:
+                            sleep_t = conc if conc < 10 else 10
+                            time.sleep(sleep_t)
+
+                        with cond:
+                            cond.notify_all()
+                            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}")
+
+                if qps > max_qps:
+                    max_qps = 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}")
+            traceback.print_exc()
+
+            # No results available, raise exception
+            if max_qps == 0.0:
+                raise e from None
+
+        finally:
+            self.stop()
+
+        return max_qps
+
+
+    def search_by_dur(self, dur: int, test_data: list[list[float]], q: mp.Queue, cond: mp.Condition) -> int:
+        # sync all process
+        q.put(1)
+        with cond:
+            cond.wait()
+
+        with self.db.init():
+            num, idx = len(test_data), random.randint(0, len(test_data) - 1)
+
+            start_time = time.perf_counter()
+            count = 0
+            while time.perf_counter() < start_time + dur:
+                s = time.perf_counter()
+                try:
+                    self.db.search_embedding(
+                        test_data[idx],
+                        self.k,
+                        self.filters,
+                    )
+                except Exception as e:
+                    log.warning(f"VectorDB search_embedding error: {e}")
+                    traceback.print_exc(chain=True)
+                    raise e from None
+
+                count += 1
+                # loop through the test data
+                idx = idx + 1 if idx < num - 1 else 0
+
+                if count % 500 == 0:
+                    log.debug(f"({mp.current_process().name:16}) search_count: {count}, 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}"
+         )
+
+        return count
+

vectordb_bench/backend/runner/rate_runner.py

@@ -0,0 +1,79 @@
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor
+import multiprocessing as mp
+
+
+from vectordb_bench.backend.clients import api
+from vectordb_bench.backend.dataset import DataSetIterator
+from vectordb_bench.backend.utils import time_it
+from vectordb_bench import config
+
+from .util import get_data, is_futures_completed, get_future_exceptions
+log = logging.getLogger(__name__)
+
+
+class RatedMultiThreadingInsertRunner:
+    def __init__(
+        self,
+        rate: int, # numRows per second
+        db: api.VectorDB,
+        dataset_iter: DataSetIterator,
+        normalize: bool = False,
+        timeout: float | None = None,
+    ):
+        self.timeout = timeout if isinstance(timeout, (int, float)) else None
+        self.dataset = dataset_iter
+        self.db = db
+        self.normalize = normalize
+        self.insert_rate = rate
+        self.batch_rate = rate // config.NUM_PER_BATCH
+
+    def send_insert_task(self, db, emb: list[list[float]], metadata: list[str]):
+        db.insert_embeddings(emb, metadata)
+
+    @time_it
+    def run_with_rate(self, q: mp.Queue):
+        with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
+            executing_futures = []
+
+            @time_it
+            def submit_by_rate() -> bool:
+                rate = self.batch_rate
+                for data in self.dataset:
+                    emb, metadata = get_data(data, self.normalize)
+                    executing_futures.append(executor.submit(self.send_insert_task, self.db, emb, metadata))
+                    rate -= 1
+
+                    if rate == 0:
+                        return False
+                return rate == self.batch_rate
+
+            with self.db.init():
+                while True:
+                    start_time = time.perf_counter()
+                    finished, elapsed_time = submit_by_rate()
+                    if finished is True:
+                        q.put(None, block=True)
+                        log.info(f"End of dataset, left unfinished={len(executing_futures)}")
+                        return
+
+                    q.put(True, block=False)
+                    wait_interval = 1 - elapsed_time if elapsed_time < 1 else 0.001
+
+                    e, completed = is_futures_completed(executing_futures, wait_interval)
+                    if completed is True:
+                        ex = get_future_exceptions(executing_futures)
+                        if ex is not None:
+                            log.warn(f"task error, terminating, err={ex}")
+                            q.put(None)
+                            executor.shutdown(wait=True, cancel_futures=True)
+                            raise ex
+                        else:
+                            log.debug(f"Finished {len(executing_futures)} insert-{config.NUM_PER_BATCH} task in 1s, wait_interval={wait_interval:.2f}")
+                        executing_futures = []
+                    else:
+                        log.warning(f"Failed to finish tasks in 1s, {e}, waited={wait_interval:.2f}, try to check the next round")
+                    dur = time.perf_counter() - start_time
+                    if dur < 1:
+                        time.sleep(1 - dur)

vectordb_bench/backend/runner/read_write_runner.py

@@ -0,0 +1,112 @@
+import logging
+from typing import Iterable
+import multiprocessing as mp
+import concurrent
+import numpy as np
+import math
+
+from .mp_runner import MultiProcessingSearchRunner
+from .serial_runner import SerialSearchRunner
+from .rate_runner import RatedMultiThreadingInsertRunner
+from vectordb_bench.backend.clients import api
+from vectordb_bench.backend.dataset import DatasetManager
+
+log = logging.getLogger(__name__)
+
+
+class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunner):
+    def __init__(
+        self,
+        db: api.VectorDB,
+        dataset: DatasetManager,
+        insert_rate: int = 1000,
+        normalize: bool = False,
+        k: int = 100,
+        filters: dict | None = None,
+        concurrencies: Iterable[int] = (1, 15, 50),
+        search_stage: Iterable[float] = (0.5, 0.6, 0.7, 0.8, 0.9, 1.0), # search in any insert portion, 0.0 means search from the start
+        read_dur_after_write: int = 300, # seconds, search duration when insertion is done
+        timeout: float | None = None,
+    ):
+        self.insert_rate = insert_rate
+        self.data_volume = dataset.data.size
+
+        for stage in search_stage:
+            assert 0.0 <= stage <= 1.0, "each search stage should be in [0.0, 1.0]"
+        self.search_stage = sorted(search_stage)
+        self.read_dur_after_write = read_dur_after_write
+
+        log.info(f"Init runner, concurencys={concurrencies}, search_stage={search_stage}, stage_search_dur={read_dur_after_write}")
+
+        test_emb = np.stack(dataset.test_data["emb"])
+        if normalize:
+            test_emb = test_emb / np.linalg.norm(test_emb, axis=1)[:, np.newaxis]
+        test_emb = test_emb.tolist()
+
+        MultiProcessingSearchRunner.__init__(
+            self,
+            db=db,
+            test_data=test_emb,
+            k=k,
+            filters=filters,
+            concurrencies=concurrencies,
+        )
+        RatedMultiThreadingInsertRunner.__init__(
+            self,
+            rate=insert_rate,
+            db=db,
+            dataset_iter=iter(dataset),
+            normalize=normalize,
+        )
+        self.serial_search_runner = SerialSearchRunner(
+            db=db,
+            test_data=test_emb,
+            ground_truth=dataset.gt_data,
+            k=k,
+        )
+
+    def run_read_write(self):
+        futures = []
+        with mp.Manager() as m:
+            q = m.Queue()
+            with concurrent.futures.ProcessPoolExecutor(mp_context=mp.get_context("spawn"), max_workers=2) as executor:
+                futures.append(executor.submit(self.run_with_rate, q))
+                futures.append(executor.submit(self.run_search_by_sig, q))
+
+                for future in concurrent.futures.as_completed(futures):
+                    res = future.result()
+                    log.info(f"Result = {res}")
+
+        log.info("Concurrent read write all done")
+
+
+    def run_search_by_sig(self, q):
+        res = []
+        total_batch = math.ceil(self.data_volume / self.insert_rate)
+        batch = 0
+        recall = 'x'
+
+        for idx, stage in enumerate(self.search_stage):
+            target_batch = int(total_batch * stage)
+            while q.get(block=True):
+                batch += 1
+                if batch >= target_batch:
+                    perc = int(stage * 100)
+                    log.info(f"Insert {perc}% done, total batch={total_batch}")
+                    log.info(f"[{batch}/{total_batch}] Serial search - {perc}% start")
+                    recall, ndcg, p99 =self.serial_search_runner.run()
+
+                    if idx < len(self.search_stage) - 1:
+                        stage_search_dur = (self.data_volume  * (self.search_stage[idx + 1] - stage) // self.insert_rate) // len(self.concurrencies)
+                        if stage_search_dur < 30:
+                            log.warning(f"Search duration too short, please reduce concurrency count or insert rate, or increase dataset volume: dur={stage_search_dur}, concurrencies={len(self.concurrencies)}, insert_rate={self.insert_rate}")
+                        log.info(f"[{batch}/{total_batch}] Conc search - {perc}% start, dur for each conc={stage_search_dur}s")
+                    else:
+                        last_search_dur = self.data_volume * (1.0 - stage) // self.insert_rate
+                        stage_search_dur = last_search_dur + self.read_dur_after_write
+                        log.info(f"[{batch}/{total_batch}] Last conc search - {perc}% start, [read_until_write|read_after_write|total] =[{last_search_dur}s|{self.read_dur_after_write}s|{stage_search_dur}s]")
+
+                    max_qps = self.run_by_dur(stage_search_dur)
+                    res.append((perc, max_qps, recall))
+                    break
+        return res

vectordb_bench/backend/runner/util.py

@@ -0,0 +1,32 @@
+import logging
+import concurrent
+from typing import Iterable
+
+from pandas import DataFrame
+import numpy as np
+
+log = logging.getLogger(__name__)
+
+def get_data(data_df: DataFrame, normalize: bool) -> tuple[list[list[float]], list[str]]:
+    all_metadata = data_df['id'].tolist()
+    emb_np = np.stack(data_df['emb'])
+    if normalize:
+        log.debug("normalize the 100k train data")
+        all_embeddings = (emb_np / np.linalg.norm(emb_np, axis=1)[:, np.newaxis]).tolist()
+    else:
+        all_embeddings = emb_np.tolist()
+    return all_embeddings, all_metadata
+
+def is_futures_completed(futures: Iterable[concurrent.futures.Future], interval) -> (Exception, bool):
+    try:
+        list(concurrent.futures.as_completed(futures, timeout=interval))
+    except TimeoutError as e:
+        return e, False
+    return None, True
+
+
+def get_future_exceptions(futures: Iterable[concurrent.futures.Future]) -> BaseException | None:
+    for f in futures:
+        if f.exception() is not None:
+            return f.exception()
+    return

vectordb_bench/backend/task_runner.py

@@ -150,7 +150,7 @@ class CaseRunner(BaseModel):
                 )
 
             self._init_search_runner()
-    
+
             m.qps, m.conc_num_list, m.conc_qps_list, m.conc_latency_p99_list = self._conc_search()
             m.recall, m.serial_latency_p99 = self._serial_search()
         '''
@@ -176,6 +176,9 @@ class CaseRunner(BaseModel):
                 or TaskStage.SEARCH_CONCURRENT in self.config.stages
             ):
                 self._init_search_runner()
+                if TaskStage.SEARCH_CONCURRENT in self.config.stages:
+                    search_results = self._conc_search()
+                    m.qps, m.conc_num_list, m.conc_qps_list, m.conc_latency_p99_list, m.conc_latency_avg_list = search_results
                 if TaskStage.SEARCH_SERIAL in self.config.stages:
                     search_results = self._serial_search()
                     '''
@@ -183,10 +186,7 @@ class CaseRunner(BaseModel):
                     m.serial_latencies = search_results.serial_latencies
                     '''
                     m.recall, m.ndcg, m.serial_latency_p99 = search_results
-                if TaskStage.SEARCH_CONCURRENT in self.config.stages:
-                    search_results = self._conc_search()
-                    m.qps, m.conc_num_list, m.conc_qps_list, m.conc_latency_p99_list = search_results
-            
+
         except Exception as e:
             log.warning(f"Failed to run performance case, reason = {e}")
             traceback.print_exc()

vectordb_bench/frontend/components/concurrent/charts.py

@@ -6,7 +6,7 @@ import plotly.express as px
 from vectordb_bench.frontend.config.styles import COLOR_MAP
 
 
-def drawChartsByCase(allData, showCaseNames: list[str], st):
+def drawChartsByCase(allData, showCaseNames: list[str], st, latency_type: str):
     initMainExpanderStyle(st)
     for caseName in showCaseNames:
         chartContainer = st.expander(caseName, True)
@@ -14,15 +14,24 @@ def drawChartsByCase(allData, showCaseNames: list[str], st):
         data = [
             {
                 "conc_num": caseData["conc_num_list"][i],
-                "qps": caseData["conc_qps_list"][i],
-                "latency_p99": caseData["conc_latency_p99_list"][i] * 1000,
+                "qps": caseData["conc_qps_list"][i]
+                if 0 <= i < len(caseData["conc_qps_list"])
+                else 0,
+                "latency_p99": caseData["conc_latency_p99_list"][i] * 1000
+                if 0 <= i < len(caseData["conc_latency_p99_list"])
+                else 0,
+                "latency_avg": caseData["conc_latency_avg_list"][i] * 1000
+                if 0 <= i < len(caseData["conc_latency_avg_list"])
+                else 0,
                 "db_name": caseData["db_name"],
                 "db": caseData["db"],
             }
             for caseData in caseDataList
             for i in range(len(caseData["conc_num_list"]))
         ]
-        drawChart(data, chartContainer, key=f"{caseName}-qps-p99")
+        drawChart(
+            data, chartContainer, key=f"{caseName}-qps-p99", x_metric=latency_type
+        )
 
 
 def getRange(metric, data, padding_multipliers):
@@ -36,14 +45,21 @@ def getRange(metric, data, padding_multipliers):
     return rangeV
 
 
-def drawChart(data, st, key: str):
+def gen_title(s: str) -> str:
+    if "latency" in s:
+        return f'{s.replace("_", " ").title()} (ms)'
+    else:
+        return s.upper()
+
+
+def drawChart(data, st, key: str, x_metric: str = "latency_p99", y_metric: str = "qps"):
     if len(data) == 0:
         return
 
-    x = "latency_p99"
+    x = x_metric
     xrange = getRange(x, data, [0.05, 0.1])
 
-    y = "qps"
+    y = y_metric
     yrange = getRange(y, data, [0.2, 0.1])
 
     color = "db"
@@ -69,8 +85,8 @@ def drawChart(data, st, key: str):
         },
         height=720,
     )
-    fig.update_xaxes(range=xrange, title_text="Latency P99 (ms)")
-    fig.update_yaxes(range=yrange, title_text="QPS")
+    fig.update_xaxes(range=xrange, title_text=gen_title(x_metric))
+    fig.update_yaxes(range=yrange, title_text=gen_title(y_metric))
     fig.update_traces(textposition="bottom right", texttemplate="conc-%{text:,.4~r}")
 
     st.plotly_chart(fig, use_container_width=True, key=key)

vectordb_bench/frontend/pages/concurrent.py

@@ -55,7 +55,11 @@ def main():
     resultesContainer = st.sidebar.container()
     getResults(resultesContainer, "vectordb_bench_concurrent")
 
-    drawChartsByCase(shownData, showCaseNames, st.container())
+    # main
+    latency_type = st.radio("Latency Type", options=["latency_p99", "latency_avg"])
+    drawChartsByCase(
+        shownData, showCaseNames, st.container(), latency_type=latency_type
+    )
 
     # footer
     footer(st.container())

vectordb_bench/metric.py

@@ -23,6 +23,7 @@ class Metric:
     conc_num_list: list[int] = field(default_factory=list)
     conc_qps_list: list[float] = field(default_factory=list)
     conc_latency_p99_list: list[float] = field(default_factory=list)
+    conc_latency_avg_list: list[float] = field(default_factory=list)
 
 
 QURIES_PER_DOLLAR_METRIC = "QP$ (Quries per Dollar)"

{vectordb_bench-0.0.16.dist-info → vectordb_bench-0.0.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vectordb-bench
-Version: 0.0.16
+Version: 0.0.17
 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
@@ -14,7 +14,7 @@ Requires-Dist: click
 Requires-Dist: pytz
 Requires-Dist: streamlit-autorefresh
 Requires-Dist: streamlit!=1.34.0
-Requires-Dist: streamlit-extras
+Requires-Dist: streamlit_extras
 Requires-Dist: tqdm
 Requires-Dist: s3fs
 Requires-Dist: oss2
@@ -25,6 +25,9 @@ Requires-Dist: environs
 Requires-Dist: pydantic<v2
 Requires-Dist: scikit-learn
 Requires-Dist: pymilvus
+Provides-Extra: test
+Requires-Dist: ruff; extra == "test"
+Requires-Dist: pytest; extra == "test"
 Provides-Extra: all
 Requires-Dist: grpcio==1.53.0; extra == "all"
 Requires-Dist: grpcio-tools==1.53.0; extra == "all"
@@ -33,7 +36,7 @@ Requires-Dist: pinecone-client; extra == "all"
 Requires-Dist: weaviate-client; extra == "all"
 Requires-Dist: elasticsearch; extra == "all"
 Requires-Dist: pgvector; extra == "all"
-Requires-Dist: pgvecto-rs[psycopg3]>=0.2.2; extra == "all"
+Requires-Dist: pgvecto_rs[psycopg3]>=0.2.2; extra == "all"
 Requires-Dist: sqlalchemy; extra == "all"
 Requires-Dist: redis; extra == "all"
 Requires-Dist: chromadb; extra == "all"
@@ -41,20 +44,14 @@ Requires-Dist: psycopg; extra == "all"
 Requires-Dist: psycopg-binary; extra == "all"
 Requires-Dist: opensearch-dsl==2.1.0; extra == "all"
 Requires-Dist: opensearch-py==2.6.0; extra == "all"
-Provides-Extra: awsopensearch
-Requires-Dist: awsopensearch; extra == "awsopensearch"
-Provides-Extra: chromadb
-Requires-Dist: chromadb; extra == "chromadb"
+Provides-Extra: qdrant
+Requires-Dist: qdrant-client; extra == "qdrant"
+Provides-Extra: pinecone
+Requires-Dist: pinecone-client; extra == "pinecone"
+Provides-Extra: weaviate
+Requires-Dist: weaviate-client; extra == "weaviate"
 Provides-Extra: elastic
 Requires-Dist: elasticsearch; extra == "elastic"
-Provides-Extra: memorydb
-Requires-Dist: memorydb; extra == "memorydb"
-Provides-Extra: pgdiskann
-Requires-Dist: psycopg; extra == "pgdiskann"
-Requires-Dist: psycopg-binary; extra == "pgdiskann"
-Requires-Dist: pgvector; extra == "pgdiskann"
-Provides-Extra: pgvecto_rs
-Requires-Dist: pgvecto-rs[psycopg3]>=0.2.2; extra == "pgvecto-rs"
 Provides-Extra: pgvector
 Requires-Dist: psycopg; extra == "pgvector"
 Requires-Dist: psycopg-binary; extra == "pgvector"
@@ -63,18 +60,21 @@ Provides-Extra: pgvectorscale
 Requires-Dist: psycopg; extra == "pgvectorscale"
 Requires-Dist: psycopg-binary; extra == "pgvectorscale"
 Requires-Dist: pgvector; extra == "pgvectorscale"
-Provides-Extra: pinecone
-Requires-Dist: pinecone-client; extra == "pinecone"
-Provides-Extra: qdrant
-Requires-Dist: qdrant-client; extra == "qdrant"
+Provides-Extra: pgdiskann
+Requires-Dist: psycopg; extra == "pgdiskann"
+Requires-Dist: psycopg-binary; extra == "pgdiskann"
+Requires-Dist: pgvector; extra == "pgdiskann"
+Provides-Extra: pgvecto-rs
+Requires-Dist: pgvecto_rs[psycopg3]>=0.2.2; extra == "pgvecto-rs"
 Provides-Extra: redis
 Requires-Dist: redis; extra == "redis"
-Provides-Extra: test
-Requires-Dist: ruff; extra == "test"
-Requires-Dist: pytest; extra == "test"
-Provides-Extra: weaviate
-Requires-Dist: weaviate-client; extra == "weaviate"
-Provides-Extra: zilliz_cloud
+Provides-Extra: memorydb
+Requires-Dist: memorydb; extra == "memorydb"
+Provides-Extra: chromadb
+Requires-Dist: chromadb; extra == "chromadb"
+Provides-Extra: awsopensearch
+Requires-Dist: awsopensearch; extra == "awsopensearch"
+Provides-Extra: zilliz-cloud
 
 # VectorDBBench: A Benchmark Tool for VectorDB
 

{vectordb_bench-0.0.16.dist-info → vectordb_bench-0.0.17.dist-info}/RECORD

@@ -1,17 +1,17 @@
-vectordb_bench/__init__.py,sha256=6eCX-hQJJtc97zlz6qcwJHrdwfAtkkwMSZEYeK9RRN0,2152
+vectordb_bench/__init__.py,sha256=sma1LoKYvRHXYmNKHgz1TT3oy-65scS9ZoF5o5b30SM,2151
 vectordb_bench/__main__.py,sha256=YJOTn5MlbmLyr3PRsecY6fj7igHLB6_D3y1HwF_sO20,848
 vectordb_bench/base.py,sha256=d34WCGXZI1u5RGQtqrPHd3HbOF5AmioFrM2j30Aj1sY,130
 vectordb_bench/interface.py,sha256=ZT3pseyq--TuxtopdP2hRut-6vIInKo62pvAl2zBD10,9708
 vectordb_bench/log_util.py,sha256=nMnW-sN24WyURcI07t-WA3q2N5R-YIvFgboRsSrNJDg,2906
-vectordb_bench/metric.py,sha256=osb58NvGGmqs3EKTfFujO7Qq5fAhGO9AOkCsziKgEUs,1976
+vectordb_bench/metric.py,sha256=c-LAxCtb55txnsfd3FN4gRpRif8RREhKRF0eg2JmHGc,2045
 vectordb_bench/models.py,sha256=jAY60QFq3Uhq0YPIQOGYBU1JspOz8D0XJEXSlEBT7cs,10645
 vectordb_bench/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectordb_bench/backend/assembler.py,sha256=mmoLzWXFSlrpWvaVY41wiRNWNv2IR-LzlANX55MJbYI,2028
 vectordb_bench/backend/cases.py,sha256=lQ9jgKaJGunj-mJXR3cgGt16wCsrDrvs-GS3ycTDk0U,16169
 vectordb_bench/backend/data_source.py,sha256=j4-eD0nIe7Y6fSM5WKEij3GfhyU_YOQ3L5Tyl-1GxX0,5446
-vectordb_bench/backend/dataset.py,sha256=WHHNDIOrO6eyU3LsW4SxDeZT-_u0dMFwKigNB5kWMk0,8764
+vectordb_bench/backend/dataset.py,sha256=MZSu0Q3AkK9gxiuLKNTMH6hhucKK668j4G1-8emhS18,8786
 vectordb_bench/backend/result_collector.py,sha256=jdQf5-q1z5y07SKy9Sig1wFROmm-p9x_Y81fId0sjaU,807
-vectordb_bench/backend/task_runner.py,sha256=Y1HYWvWlIo_4pe0EMLuAN8bWj2xhqfbw59afbCmZeAI,11855
+vectordb_bench/backend/task_runner.py,sha256=cn_RRDyFfNSLlTT84W-ZaXvdl54pK6Cxcsp9ucNRcCs,11864
 vectordb_bench/backend/utils.py,sha256=2UixYyfKvl8zRiashywB1l6hTI3jMtiZhiVm_bXHV1Y,1811
 vectordb_bench/backend/clients/__init__.py,sha256=vl-ldJCTAm6aXUNZS4xE5M2zbiWSz9-rua_9PcOj7ZA,6277
 vectordb_bench/backend/clients/api.py,sha256=KGHdn8gewGm_HbsF7qfn3ibep4AoMXUzaoTjLpF98NE,6176
@@ -28,7 +28,7 @@ vectordb_bench/backend/clients/memorydb/config.py,sha256=PjhLMMr_LdJ8O91JpHNCCT6
 vectordb_bench/backend/clients/memorydb/memorydb.py,sha256=XIqtXpY-2lJohIuImFDsRO3c_upn04eCplIOlaLxFo4,10114
 vectordb_bench/backend/clients/milvus/cli.py,sha256=QqzYIOeUSXEvdLH0_YUMhwDHUDJirTNKeUxrJQIqSdw,8506
 vectordb_bench/backend/clients/milvus/config.py,sha256=AZ4QHoufRIjsX2eVrtnug8SeYnuHeBMna_34OQNFxz0,6847
-vectordb_bench/backend/clients/milvus/milvus.py,sha256=BzOySmlYCQnNScazK9XBjKPh3X99jZSm0W3-IigRAYY,7653
+vectordb_bench/backend/clients/milvus/milvus.py,sha256=BhEkJr8ZQuiFqYd1sQYhKd8YXHS9vlaqOv36zlHI6xc,7712
 vectordb_bench/backend/clients/pgdiskann/cli.py,sha256=ued1DyufltataIk6KcmBkNp8PdB9Aj65nVJ6WhrD_VI,3130
 vectordb_bench/backend/clients/pgdiskann/config.py,sha256=8E0GLgUxa5LlJ_eXCugbbO08qdbCVqc1wtdsoOsKEW4,4444
 vectordb_bench/backend/clients/pgdiskann/pgdiskann.py,sha256=bEcbpTVSFxRJ5HiJTX77cgu6NqTMPs8qiGeMF7jBC30,12628
@@ -58,8 +58,11 @@ vectordb_bench/backend/clients/zilliz_cloud/cli.py,sha256=V8XnjrM4IOexqJksQCBgEY
 vectordb_bench/backend/clients/zilliz_cloud/config.py,sha256=3Tk7X4r0n2SLzan110xlF63otVGjCKe28CVDfCEI04c,910
 vectordb_bench/backend/clients/zilliz_cloud/zilliz_cloud.py,sha256=4JcwiVEJcdEykW6n471nfHeIlmhIDa-gOZ7G5H_4krY,681
 vectordb_bench/backend/runner/__init__.py,sha256=5dZfPky8pY9Bi9HD5GZ3Fge8V2FJWrkGkQUkNL2v1t0,230
-vectordb_bench/backend/runner/mp_runner.py,sha256=u8UqIp44fSIEhT5M9-RQEiaFwOlxLA0L5n989hCv3hY,5456
+vectordb_bench/backend/runner/mp_runner.py,sha256=sPJJWg6bKSQYsyWEe5y_j8i_Cf9l5buhtyY-wZxXDAI,9080
+vectordb_bench/backend/runner/rate_runner.py,sha256=qLfirLmS9tR0-3jljaWD_AMw_gt6nwhAVVkxhoo4F4A,3195
+vectordb_bench/backend/runner/read_write_runner.py,sha256=B8PD_gRS5K1nFH5004x6ON1Z8TulK7c4QepW3Glltd8,4732
 vectordb_bench/backend/runner/serial_runner.py,sha256=ku1Dtps9JcmwCwZq7eDw0pcP9IN2Zjjg-1VJumXYJpA,9414
+vectordb_bench/backend/runner/util.py,sha256=pGJn-qXWwGXVlmsMulaqH0zXcasDWjsVwwOJeDFWXhc,1032
 vectordb_bench/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectordb_bench/cli/cli.py,sha256=Z2-vLwvnnZFsVAPyjFK557cZZYWX_q60XVJP-aYUGdc,15416
 vectordb_bench/cli/vectordbbench.py,sha256=QOKwURuiaxsQ-vf7ji-qHEug5j1y_j1xSeykSsENz30,1055
@@ -76,7 +79,7 @@ vectordb_bench/frontend/components/check_results/headerIcon.py,sha256=0uvvSe-oro
 vectordb_bench/frontend/components/check_results/nav.py,sha256=DQl74rujw70ayh37PQaiO4AdtVZ95-OtTMEtw_Ui7hE,685
 vectordb_bench/frontend/components/check_results/priceTable.py,sha256=n7OLXfG95CECPR9lQuK_7HXd3jjprmuk8EHgJ8hcth4,1309
 vectordb_bench/frontend/components/check_results/stPageConfig.py,sha256=vHDHS3qwAbOAQ-Zvz3DftUiKJS4Xs109172aWUmzOt0,430
-vectordb_bench/frontend/components/concurrent/charts.py,sha256=_fredxaByBkzEe_2NDX31yNxwi_EnReknUm1nqCcgbs,2218
+vectordb_bench/frontend/components/concurrent/charts.py,sha256=H1FSMrnwzmqUInJoHGLVceqLm0-CJ66ujbSNVQJ_SBg,2830
 vectordb_bench/frontend/components/custom/displayCustomCase.py,sha256=oZfvtiCWr3VnHdvXgcf5YoqvtPWsfMN-YOT7KKoIxp4,1613
 vectordb_bench/frontend/components/custom/displaypPrams.py,sha256=pxpHgnyGItxkwbajI8qIun0YBY23ZZAvsnK5z7_g5p4,1321
 vectordb_bench/frontend/components/custom/getCustomConfig.py,sha256=P0WCMla2hmzeDcsHju6gFMQrugsBzajAVSYtBZTEwWg,1050
@@ -94,7 +97,7 @@ vectordb_bench/frontend/components/tables/data.py,sha256=pVG_hb4bTMLfUt10NUCJSqc
 vectordb_bench/frontend/config/dbCaseConfigs.py,sha256=Sl6sPTtUJki8uRu5wgPynKcR4OdaDwIgnmzCVVX9gQ0,31070
 vectordb_bench/frontend/config/dbPrices.py,sha256=10aBKjVcEg8y7TPSda28opmBM1KmXNrvbU9WM_BsZcE,176
 vectordb_bench/frontend/config/styles.py,sha256=E2PmwmiewxBKJJ59hQ4ZXatqg8QTN-Z53JlsvWMHM2M,2291
-vectordb_bench/frontend/pages/concurrent.py,sha256=yK62Tjto8G9ObvLy0JSVLq9fqDMy_D3oAEGZw2Te4gU,1958
+vectordb_bench/frontend/pages/concurrent.py,sha256=z2izkQ0suO5mZ8PpVY2jypZkF5VT8xUkQQEkwd6C-ww,2094
 vectordb_bench/frontend/pages/custom.py,sha256=BYQuWa7_OQz0wnDvh0LiXzjevmDpO2BbSIuF1_Z_39M,2234
 vectordb_bench/frontend/pages/quries_per_dollar.py,sha256=SRLPjGfXwZOIrLeDLgVNg1kE6xjAu-QfmXoa3Sfiqi8,2510
 vectordb_bench/frontend/pages/run_test.py,sha256=b1NoMhFA3MmUyItkofh3xozvo1vAqywXKOsoWdIWmRU,2161
@@ -117,9 +120,9 @@ vectordb_bench/results/WeaviateCloud/result_20230808_standard_weaviatecloud.json
 vectordb_bench/results/ZillizCloud/result_20230727_standard_zillizcloud.json,sha256=-Mdm4By65XDRCrmVOCF8yQXjcZtH4Xo4shcjoDoBUKU,18293
 vectordb_bench/results/ZillizCloud/result_20230808_standard_zillizcloud.json,sha256=77XlHT5zM_K7mG5HfDQKwXZnSCuR37VUbt6-P3J_amI,15737
 vectordb_bench/results/ZillizCloud/result_20240105_standard_202401_zillizcloud.json,sha256=TualfJ0664Hs-vdIW68bdkqAEYyzotXmu2P0yIN-GHk,42526
-vectordb_bench-0.0.16.dist-info/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
-vectordb_bench-0.0.16.dist-info/METADATA,sha256=CpbILuoA-dYaH1oQs0Bm08mExmD0kx5wfk8UbXPRIzc,34643
-vectordb_bench-0.0.16.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-vectordb_bench-0.0.16.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
-vectordb_bench-0.0.16.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
-vectordb_bench-0.0.16.dist-info/RECORD,,
+vectordb_bench-0.0.17.dist-info/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
+vectordb_bench-0.0.17.dist-info/METADATA,sha256=SreMZtCcdr-dKZrwyLXuVHX-WinJe9uLTvV9_NtIXgY,34643
+vectordb_bench-0.0.17.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+vectordb_bench-0.0.17.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
+vectordb_bench-0.0.17.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
+vectordb_bench-0.0.17.dist-info/RECORD,,

{vectordb_bench-0.0.16.dist-info → vectordb_bench-0.0.17.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any