vectordb-bench 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

vectordb_bench/backend/clients/pgvectorscale/pgvectorscale.py

@@ -0,0 +1,272 @@
+"""Wrapper around the Pgvectorscale vector database over VectorDB"""
+
+import logging
+import pprint
+from contextlib import contextmanager
+from typing import Any, Generator, Optional, Tuple
+
+import numpy as np
+import psycopg
+from pgvector.psycopg import register_vector
+from psycopg import Connection, Cursor, sql
+
+from ..api import VectorDB
+from .config import PgVectorScaleConfigDict, PgVectorScaleIndexConfig
+
+log = logging.getLogger(__name__)
+
+
+class PgVectorScale(VectorDB):
+    """Use psycopg instructions"""
+
+    conn: psycopg.Connection[Any] | None = None
+    coursor: psycopg.Cursor[Any] | None = None
+
+    def __init__(
+        self,
+        dim: int,
+        db_config: PgVectorScaleConfigDict,
+        db_case_config: PgVectorScaleIndexConfig,
+        collection_name: str = "pg_vectorscale_collection",
+        drop_old: bool = False,
+        **kwargs,
+    ):
+        self.name = "PgVectorScale"
+        self.db_config = db_config
+        self.case_config = db_case_config
+        self.table_name = collection_name
+        self.dim = dim
+
+        self._index_name = "pgvectorscale_index"
+        self._primary_field = "id"
+        self._vector_field = "embedding"
+
+        self.conn, self.cursor = self._create_connection(**self.db_config)        
+
+        log.info(f"{self.name} config values: {self.db_config}\n{self.case_config}")
+        if not any(
+            (
+                self.case_config.create_index_before_load,
+                self.case_config.create_index_after_load,
+            )
+        ):
+            err = f"{self.name} config must create an index using create_index_before_load or create_index_after_load"
+            log.error(err)
+            raise RuntimeError(
+                f"{err}\n{pprint.pformat(self.db_config)}\n{pprint.pformat(self.case_config)}"
+            )
+
+        if drop_old:
+            self._drop_index()
+            self._drop_table()
+            self._create_table(dim)
+            if self.case_config.create_index_before_load:
+                self._create_index()
+
+        self.cursor.close()
+        self.conn.close()
+        self.cursor = None
+        self.conn = None
+
+    @staticmethod
+    def _create_connection(**kwargs) -> Tuple[Connection, Cursor]:
+        conn = psycopg.connect(**kwargs)
+        conn.cursor().execute("CREATE EXTENSION IF NOT EXISTS vectorscale CASCADE")
+        conn.commit()
+        register_vector(conn)
+        conn.autocommit = False
+        cursor = conn.cursor()
+
+        assert conn is not None, "Connection is not initialized"
+        assert cursor is not None, "Cursor is not initialized"
+
+        return conn, cursor
+
+    @contextmanager
+    def init(self) -> Generator[None, None, None]:
+        self.conn, self.cursor = self._create_connection(**self.db_config)
+
+        # index configuration may have commands defined that we should set during each client session
+        session_options: dict[str, Any] = self.case_config.session_param()
+
+        if len(session_options) > 0:
+            for setting_name, setting_val in session_options.items():
+                command = sql.SQL("SET {setting_name} " + "= {setting_val};").format(
+                    setting_name=sql.Identifier(setting_name),
+                    setting_val=sql.Identifier(str(setting_val)),
+                )
+                log.debug(command.as_string(self.cursor))
+                self.cursor.execute(command)
+            self.conn.commit()
+        
+        self._unfiltered_search = sql.Composed(
+            [
+                sql.SQL("SELECT id FROM public.{} ORDER BY embedding ").format(
+                    sql.Identifier(self.table_name)
+                ),
+                sql.SQL(self.case_config.search_param()["metric_fun_op"]),
+                sql.SQL(" %s::vector LIMIT %s::int"),
+            ]
+        )
+
+        try:
+            yield
+        finally:
+            self.cursor.close()
+            self.conn.close()
+            self.cursor = None
+            self.conn = None
+
+    def _drop_table(self):
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+        log.info(f"{self.name} client drop table : {self.table_name}")
+
+        self.cursor.execute(
+            sql.SQL("DROP TABLE IF EXISTS public.{table_name}").format(
+                table_name=sql.Identifier(self.table_name)
+            )
+        )
+        self.conn.commit()
+
+    def ready_to_load(self):
+        pass
+
+    def optimize(self):
+        self._post_insert()
+
+    def _post_insert(self):
+        log.info(f"{self.name} post insert before optimize")
+        if self.case_config.create_index_after_load:
+            self._drop_index()
+            self._create_index()
+
+    def _drop_index(self):
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+        log.info(f"{self.name} client drop index : {self._index_name}")
+
+        drop_index_sql = sql.SQL("DROP INDEX IF EXISTS {index_name}").format(
+            index_name=sql.Identifier(self._index_name)
+        )
+        log.debug(drop_index_sql.as_string(self.cursor))
+        self.cursor.execute(drop_index_sql)
+        self.conn.commit()
+
+    def _create_index(self):
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+        log.info(f"{self.name} client create index : {self._index_name}")
+
+        index_param: dict[str, Any] = self.case_config.index_param()
+
+        options = []
+        for option_name, option_val in index_param["options"].items():
+            if option_val is not None:
+                options.append(
+                    sql.SQL("{option_name} = {val}").format(
+                        option_name=sql.Identifier(option_name),
+                        val=sql.Identifier(str(option_val)),
+                    )
+                )
+        
+        num_bits_per_dimension = "2" if self.dim < 900 else "1"
+        options.append(
+            sql.SQL("{option_name} = {val}").format(
+                option_name=sql.Identifier("num_bits_per_dimension"),
+                val=sql.Identifier(num_bits_per_dimension),
+            )
+        )
+
+        if any(options):
+            with_clause = sql.SQL("WITH ({});").format(sql.SQL(", ").join(options))
+        else:
+            with_clause = sql.Composed(())
+
+        index_create_sql = sql.SQL(
+            """
+            CREATE INDEX IF NOT EXISTS {index_name} ON public.{table_name} 
+            USING {index_type} (embedding {embedding_metric})
+            """
+        ).format(
+            index_name=sql.Identifier(self._index_name),
+            table_name=sql.Identifier(self.table_name),
+            index_type=sql.Identifier(index_param["index_type"].lower()),
+            embedding_metric=sql.Identifier(index_param["metric"]),
+        )
+        index_create_sql_with_with_clause = (
+            index_create_sql + with_clause
+        ).join(" ")
+        log.debug(index_create_sql_with_with_clause.as_string(self.cursor))
+        self.cursor.execute(index_create_sql_with_with_clause)
+        self.conn.commit()
+
+    def _create_table(self, dim: int):
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+
+        try:
+            log.info(f"{self.name} client create table : {self.table_name}")
+
+            self.cursor.execute(
+                sql.SQL(
+                    "CREATE TABLE IF NOT EXISTS public.{table_name} (id BIGINT PRIMARY KEY, embedding vector({dim}));"
+                ).format(table_name=sql.Identifier(self.table_name), dim=dim)
+            )
+            self.conn.commit()
+        except Exception as e:
+            log.warning(
+                f"Failed to create pgvectorscale table: {self.table_name} error: {e}"
+            )
+            raise e from None
+
+    def insert_embeddings(
+        self,
+        embeddings: list[list[float]],
+        metadata: list[int],
+        **kwargs: Any,
+    ) -> Tuple[int, Optional[Exception]]:
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+
+        try:
+            metadata_arr = np.array(metadata)
+            embeddings_arr = np.array(embeddings)
+
+            with self.cursor.copy(
+                sql.SQL("COPY public.{table_name} FROM STDIN (FORMAT BINARY)").format(
+                    table_name=sql.Identifier(self.table_name)
+                )
+            ) as copy:
+                copy.set_types(["bigint", "vector"])
+                for i, row in enumerate(metadata_arr):
+                    copy.write_row((row, embeddings_arr[i]))
+            self.conn.commit()
+
+            if kwargs.get("last_batch"):
+                self._post_insert()
+
+            return len(metadata), None
+        except Exception as e:
+            log.warning(
+                f"Failed to insert data into pgvector table ({self.table_name}), error: {e}"
+            )
+            return 0, e
+
+    def search_embedding(
+        self,
+        query: list[float],
+        k: int = 100,
+        filters: dict | None = None,
+        timeout: int | None = None,
+    ) -> list[int]:
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+
+        q = np.asarray(query)
+        # TODO add filters support
+        result = self.cursor.execute(
+            self._unfiltered_search, (q, k), prepare=True, binary=True
+        )
+
+        return [int(i[0]) for i in result.fetchall()]

vectordb_bench/backend/dataset.py

@@ -33,6 +33,7 @@ class BaseDataset(BaseModel):
     use_shuffled: bool
     with_gt: bool = False
     _size_label: dict[int, SizeLabel] = PrivateAttr()
+    isCustom: bool = False
 
     @validator("size")
     def verify_size(cls, v):
@@ -52,7 +53,27 @@ class BaseDataset(BaseModel):
     def file_count(self) -> int:
         return self._size_label.get(self.size).file_count
 
+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"
 
+    @property
+    def dir_name(self) -> str:
+        return self.dir
+
+    @property
+    def file_count(self) -> int:
+        return self.file_num
+    
 class LAION(BaseDataset):
     name: str = "LAION"
     dim: int = 768
@@ -186,11 +207,12 @@ class DatasetManager(BaseModel):
             gt_file, test_file = utils.compose_gt_file(filters), "test.parquet"
             all_files.extend([gt_file, test_file])
 
-        source.reader().read(
-            dataset=self.data.dir_name.lower(),
-            files=all_files,
-            local_ds_root=self.data_dir,
-        )
+        if not self.data.isCustom:
+            source.reader().read(
+                dataset=self.data.dir_name.lower(),
+                files=all_files,
+                local_ds_root=self.data_dir,
+            )
 
         if gt_file is not None and test_file is not None:
             self.test_data = self._read_file(test_file)

vectordb_bench/cli/vectordbbench.py

@@ -1,19 +1,26 @@
 from ..backend.clients.pgvector.cli import PgVectorHNSW
+from ..backend.clients.pgvecto_rs.cli import PgVectoRSHNSW, PgVectoRSIVFFlat
 from ..backend.clients.redis.cli import Redis
+from ..backend.clients.memorydb.cli import MemoryDB
 from ..backend.clients.test.cli import Test
 from ..backend.clients.weaviate_cloud.cli import Weaviate
 from ..backend.clients.zilliz_cloud.cli import ZillizAutoIndex
 from ..backend.clients.milvus.cli import MilvusAutoIndex
+from ..backend.clients.aws_opensearch.cli import AWSOpenSearch
 
 
 from .cli import cli
 
 cli.add_command(PgVectorHNSW)
+cli.add_command(PgVectoRSHNSW)
+cli.add_command(PgVectoRSIVFFlat)
 cli.add_command(Redis)
+cli.add_command(MemoryDB)
 cli.add_command(Weaviate)
 cli.add_command(Test)
 cli.add_command(ZillizAutoIndex)
 cli.add_command(MilvusAutoIndex)
+cli.add_command(AWSOpenSearch)
 
 
 if __name__ == "__main__":

vectordb_bench/custom/custom_case.json

@@ -0,0 +1,18 @@
+[
+    {
+        "name": "My Dataset (Performace Case)",
+        "description": "this is a customized dataset.",
+        "load_timeout": 36000,
+        "optimize_timeout": 36000,
+        "dataset_config": {
+            "name": "My Dataset",
+            "dir": "/my_dataset_path",
+            "size": 1000000,
+            "dim": 1024,
+            "metric_type": "L2",
+            "file_count": 1,
+            "use_shuffled": false,
+            "with_gt": true
+        }
+    }
+]

vectordb_bench/frontend/components/check_results/charts.py

@@ -1,19 +1,19 @@
 from vectordb_bench.backend.cases import Case
 from vectordb_bench.frontend.components.check_results.expanderStyle import initMainExpanderStyle
 from vectordb_bench.metric import metricOrder, isLowerIsBetterMetric, metricUnitMap
-from vectordb_bench.frontend.const.styles import *
+from vectordb_bench.frontend.config.styles import *
 from vectordb_bench.models import ResultLabel
 import plotly.express as px
 
 
-def drawCharts(st, allData, failedTasks, cases: list[Case]):
+def drawCharts(st, allData, failedTasks, caseNames: list[str]):
     initMainExpanderStyle(st)
-    for case in cases:
-        chartContainer = st.expander(case.name, True)
-        data = [data for data in allData if data["case_name"] == case.name]
+    for caseName in caseNames:
+        chartContainer = st.expander(caseName, True)
+        data = [data for data in allData if data["case_name"] == caseName]
         drawChart(data, chartContainer)
 
-        errorDBs = failedTasks[case.name]
+        errorDBs = failedTasks[caseName]
         showFailedDBs(chartContainer, errorDBs)
 
 

vectordb_bench/frontend/components/check_results/data.py

@@ -8,9 +8,9 @@ from vectordb_bench.models import CaseResult, ResultLabel
 def getChartData(
     tasks: list[CaseResult],
     dbNames: list[str],
-    cases: list[Case],
+    caseNames: list[str],
 ):
-    filterTasks = getFilterTasks(tasks, dbNames, cases)
+    filterTasks = getFilterTasks(tasks, dbNames, caseNames)
     mergedTasks, failedTasks = mergeTasks(filterTasks)
     return mergedTasks, failedTasks
 
@@ -18,14 +18,16 @@ def getChartData(
 def getFilterTasks(
     tasks: list[CaseResult],
     dbNames: list[str],
-    cases: list[Case],
+    caseNames: list[str],
 ) -> list[CaseResult]:
-    case_ids = [case.case_id for case in cases]
     filterTasks = [
         task
         for task in tasks
         if task.task_config.db_name in dbNames
-        and task.task_config.case_config.case_id in case_ids
+        and task.task_config.case_config.case_id.case_cls(
+            task.task_config.case_config.custom_case
+        ).name
+        in caseNames
     ]
     return filterTasks
 
@@ -36,16 +38,20 @@ def mergeTasks(tasks: list[CaseResult]):
         db_name = task.task_config.db_name
         db = task.task_config.db.value
         db_label = task.task_config.db_config.db_label or ""
-        case_id = task.task_config.case_config.case_id
-        dbCaseMetricsMap[db_name][case_id] = {
+        version = task.task_config.db_config.version or ""
+        case = task.task_config.case_config.case_id.case_cls(
+            task.task_config.case_config.custom_case
+        )
+        dbCaseMetricsMap[db_name][case.name] = {
             "db": db,
             "db_label": db_label,
+            "version": version,
             "metrics": mergeMetrics(
-                dbCaseMetricsMap[db_name][case_id].get("metrics", {}),
+                dbCaseMetricsMap[db_name][case.name].get("metrics", {}),
                 asdict(task.metrics),
             ),
             "label": getBetterLabel(
-                dbCaseMetricsMap[db_name][case_id].get("label", ResultLabel.FAILED),
+                dbCaseMetricsMap[db_name][case.name].get("label", ResultLabel.FAILED),
                 task.label,
             ),
         }
@@ -53,18 +59,19 @@ def mergeTasks(tasks: list[CaseResult]):
     mergedTasks = []
     failedTasks = defaultdict(lambda: defaultdict(str))
     for db_name, caseMetricsMap in dbCaseMetricsMap.items():
-        for case_id, metricInfo in caseMetricsMap.items():
+        for case_name, metricInfo in caseMetricsMap.items():
             metrics = metricInfo["metrics"]
             db = metricInfo["db"]
             db_label = metricInfo["db_label"]
+            version = metricInfo["version"]
             label = metricInfo["label"]
-            case_name = case_id.case_name
             if label == ResultLabel.NORMAL:
                 mergedTasks.append(
                     {
                         "db_name": db_name,
                         "db": db,
                         "db_label": db_label,
+                        "version": version,
                         "case_name": case_name,
                         "metricsSet": set(metrics.keys()),
                         **metrics,

vectordb_bench/frontend/components/check_results/expanderStyle.py

@@ -1,7 +1,7 @@
 def initMainExpanderStyle(st):
     st.markdown(
         """<style>
-            .main .streamlit-expanderHeader p {font-size: 20px; font-weight: 600;}
+            .main div[data-testid='stExpander'] p {font-size: 18px; font-weight: 600;}
             .main div[data-testid='stExpander'] {
                 background-color: #F6F8FA;
                 border: 1px solid #A9BDD140;

vectordb_bench/frontend/components/check_results/filters.py

@@ -1,8 +1,8 @@
 from vectordb_bench.backend.cases import Case
 from vectordb_bench.frontend.components.check_results.data import getChartData
 from vectordb_bench.frontend.components.check_results.expanderStyle import initSidebarExanderStyle
-from vectordb_bench.frontend.const.dbCaseConfigs import CASE_LIST
-from vectordb_bench.frontend.const.styles import *
+from vectordb_bench.frontend.config.dbCaseConfigs import CASE_NAME_ORDER
+from vectordb_bench.frontend.config.styles import *
 import streamlit as st
 
 from vectordb_bench.models import CaseResult, TestResult
@@ -18,11 +18,12 @@ def getshownData(results: list[TestResult], st):
     st.header("Filters")
 
     shownResults = getshownResults(results, st)
-    showDBNames, showCases = getShowDbsAndCases(shownResults, st)
+    showDBNames, showCaseNames = getShowDbsAndCases(shownResults, st)
 
-    shownData, failedTasks = getChartData(shownResults, showDBNames, showCases)
+    shownData, failedTasks = getChartData(
+        shownResults, showDBNames, showCaseNames)
 
-    return shownData, failedTasks, showCases
+    return shownData, failedTasks, showCaseNames
 
 
 def getshownResults(results: list[TestResult], st) -> list[CaseResult]:
@@ -52,12 +53,18 @@ def getshownResults(results: list[TestResult], st) -> list[CaseResult]:
     return selectedResult
 
 
-def getShowDbsAndCases(result: list[CaseResult], st) -> tuple[list[str], list[Case]]:
+def getShowDbsAndCases(result: list[CaseResult], st) -> tuple[list[str], list[str]]:
     initSidebarExanderStyle(st)
     allDbNames = list(set({res.task_config.db_name for res in result}))
     allDbNames.sort()
-    allCasesSet = set({res.task_config.case_config.case_id for res in result})
-    allCases: list[Case] = [case.case_cls() for case in CASE_LIST if case in allCasesSet]
+    allCases: list[Case] = [
+        res.task_config.case_config.case_id.case_cls(
+            res.task_config.case_config.custom_case)
+        for res in result
+    ]
+    allCaseNameSet = set({case.name for case in allCases})
+    allCaseNames = [case_name for case_name in CASE_NAME_ORDER if case_name in allCaseNameSet] + \
+        [case_name for case_name in allCaseNameSet if case_name not in CASE_NAME_ORDER]
 
     # DB Filter
     dbFilterContainer = st.container()
@@ -70,15 +77,14 @@ def getShowDbsAndCases(result: list[CaseResult], st) -> tuple[list[str], list[Ca
 
     # Case Filter
     caseFilterContainer = st.container()
-    showCases = filterView(
+    showCaseNames = filterView(
         caseFilterContainer,
         "Case Filter",
-        [case for case in allCases],
+        [caseName for caseName in allCaseNames],
         col=1,
-        optionLables=[case.name for case in allCases],
     )
 
-    return showDBNames, showCases
+    return showDBNames, showCaseNames
 
 
 def filterView(container, header, options, col, optionLables=None):
@@ -114,7 +120,8 @@ def filterView(container, header, options, col, optionLables=None):
     )
     if optionLables is None:
         optionLables = options
-    isActive = {option: st.session_state[selectAllState] for option in optionLables}
+    isActive = {option: st.session_state[selectAllState]
+                for option in optionLables}
     for i, option in enumerate(optionLables):
         isActive[option] = columns[i % col].checkbox(
             optionLables[i],

vectordb_bench/frontend/components/check_results/headerIcon.py

@@ -1,4 +1,4 @@
-from vectordb_bench.frontend.const.styles import HEADER_ICON
+from vectordb_bench.frontend.config.styles import HEADER_ICON
 
 
 def drawHeaderIcon(st):

vectordb_bench/frontend/components/check_results/priceTable.py

@@ -3,7 +3,7 @@ import pandas as pd
 from collections import defaultdict
 import streamlit as st
 
-from vectordb_bench.frontend.const.dbPrices import DB_DBLABEL_TO_PRICE
+from vectordb_bench.frontend.config.dbPrices import DB_DBLABEL_TO_PRICE
 
 
 def priceTable(container, data):

vectordb_bench/frontend/components/check_results/stPageConfig.py

@@ -1,4 +1,4 @@
-from vectordb_bench.frontend.const.styles import *
+from vectordb_bench.frontend.config.styles import *
 
 
 def initResultsPageConfig(st):

vectordb_bench/frontend/components/concurrent/charts.py

@@ -1,26 +1,27 @@
-
-
-from vectordb_bench.backend.cases import Case
-from vectordb_bench.frontend.components.check_results.expanderStyle import initMainExpanderStyle
+from vectordb_bench.frontend.components.check_results.expanderStyle import (
+    initMainExpanderStyle,
+)
 import plotly.express as px
 
-from vectordb_bench.frontend.const.styles import COLOR_MAP
+from vectordb_bench.frontend.config.styles import COLOR_MAP
 
 
-def drawChartsByCase(allData, cases: list[Case], st):
+def drawChartsByCase(allData, showCaseNames: list[str], st):
     initMainExpanderStyle(st)
-    for case in cases:
-        chartContainer = st.expander(case.name, True)
-        caseDataList = [
-            data for data in allData if data["case_name"] == case.name]
-        data = [{
-            "conc_num": caseData["conc_num_list"][i],
-            "qps": caseData["conc_qps_list"][i],
-            "latency_p99": caseData["conc_latency_p99_list"][i] * 1000,
-            "db_name": caseData["db_name"],
-            "db": caseData["db"]
-
-        } for caseData in caseDataList for i in range(len(caseData["conc_num_list"]))]
+    for caseName in showCaseNames:
+        chartContainer = st.expander(caseName, True)
+        caseDataList = [data for data in allData if data["case_name"] == caseName]
+        data = [
+            {
+                "conc_num": caseData["conc_num_list"][i],
+                "qps": caseData["conc_qps_list"][i],
+                "latency_p99": caseData["conc_latency_p99_list"][i] * 1000,
+                "db_name": caseData["db_name"],
+                "db": caseData["db"],
+            }
+            for caseData in caseDataList
+            for i in range(len(caseData["conc_num_list"]))
+        ]
         drawChart(data, chartContainer)
 
 
@@ -38,7 +39,7 @@ def getRange(metric, data, padding_multipliers):
 def drawChart(data, st):
     if len(data) == 0:
         return
-    
+
     x = "latency_p99"
     xrange = getRange(x, data, [0.05, 0.1])
 
@@ -63,7 +64,6 @@ def drawChart(data, st):
         line_group=line_group,
         text=text,
         markers=True,
-        # color_discrete_map=color_discrete_map,
         hover_data={
             "conc_num": True,
         },
@@ -71,12 +71,9 @@ def drawChart(data, st):
     )
     fig.update_xaxes(range=xrange, title_text="Latency P99 (ms)")
     fig.update_yaxes(range=yrange, title_text="QPS")
-    fig.update_traces(textposition="bottom right",
-                      texttemplate="conc-%{text:,.4~r}")
-    # fig.update_layout(
-    #     margin=dict(l=0, r=0, t=40, b=0, pad=8),
-    #     legend=dict(
-    #         orientation="h", yanchor="bottom", y=1, xanchor="right", x=1, title=""
-    #     ),
-    # )
-    st.plotly_chart(fig, use_container_width=True,)
+    fig.update_traces(textposition="bottom right", texttemplate="conc-%{text:,.4~r}")
+
+    st.plotly_chart(
+        fig,
+        use_container_width=True,
+    )