xopt 3.2.0__tar.gz → 3.2.2__tar.gz

{xopt-3.2.0 → xopt-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xopt
-Version: 3.2.0
+Version: 3.2.2
 Summary: Flexible optimization of arbitrary problems in Python.
 Author: Christopher Mayes, Ryan Roussel, Nikita Kuklev, Christopher Pierce, Sara Miskovich
 License:                                  Apache License

{xopt-3.2.0 → xopt-3.2.2}/environment.yml

@@ -15,6 +15,7 @@ dependencies:
   - tqdm
   - orjson
   - matplotlib
+  - gest-api>=0.2
 # parallel
   - mpi4py
   - dask
@@ -33,3 +34,4 @@ dependencies:
   - mkdocstrings-python
   - ruff
   - typing-extensions
+  - gest-api

{xopt-3.2.0 → xopt-3.2.2}/xopt/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.2.0'
-__version_tuple__ = version_tuple = (3, 2, 0)
+__version__ = version = '3.2.2'
+__version_tuple__ = version_tuple = (3, 2, 2)
 
-__commit_id__ = commit_id = 'g0812fd68a'
+__commit_id__ = commit_id = 'gd4c488f75'

{xopt-3.2.0 → xopt-3.2.2}/xopt/base.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import os
 from copy import deepcopy
 from typing import Any, Optional, Union
 
@@ -40,6 +41,11 @@ from .errors import DataError
 
 logger = logging.getLogger(__name__)
 
+DUMP_FILE_RENAME_MESSAGE = (
+    "The attribute `dump_file` in `Xopt` has been renamed to `xopt_dump_file`. "
+    "Support for the old name will be removed in later versions of the Xopt library."
+)
+
 
 class Xopt(XoptBaseModel):
     """
@@ -59,9 +65,13 @@ class Xopt(XoptBaseModel):
     strict : bool, optional
         A flag indicating whether exceptions raised during evaluation should stop the
         optimization process.
-    dump_file : str, optional
+    xopt_dump_file : str, optional
         An optional file path for dumping attributes of the xopt object and the
-        results of evaluations.
+        results of evaluations. Environment variables and `~` are expanded when
+        dumping.
+    data_dump_file : str, optional
+        An optional file path for dumping the evaluation data as a CSV file.
+        Environment variables and `~` are expanded when dumping.
     data : DataFrame, optional
         An optional DataFrame object for storing internal data related to the optimization
         process.
@@ -98,6 +108,8 @@ class Xopt(XoptBaseModel):
         Serializes the Xopt configuration to a YAML string.
     dump(file: str = None, **kwargs)
         Dumps the Xopt configuration to a specified file.
+    dump_data()
+        Dumps the evaluation data to the file given by `data_dump_file`.
     dict(**kwargs) -> dict
         Provides a custom dictionary representation of the Xopt configuration.
     json(**kwargs) -> str
@@ -115,8 +127,11 @@ class Xopt(XoptBaseModel):
         description="flag to indicate if exceptions raised during evaluation "
         "should stop Xopt",
     )
-    dump_file: Optional[str] = Field(
-        None, description="file to dump the results of the evaluations"
+    xopt_dump_file: Optional[str] = Field(
+        None, description="file to dump the serialized Xopt object to"
+    )
+    data_dump_file: Optional[str] = Field(
+        None, description="file to dump the evaluation data to as CSV"
     )
     data: Optional[DataFrame] = Field(None, description="internal DataFrame object")
     serialize_torch: bool = Field(
@@ -243,6 +258,35 @@ class Xopt(XoptBaseModel):
             )
         return data
 
+    @model_validator(mode="before")
+    @classmethod
+    def dump_file_legacy(cls, data: Any):
+        """
+        Handle backward compatibility: convert the old dump_file parameter to
+        xopt_dump_file.
+        """
+        if isinstance(data, dict) and "dump_file" in data:
+            warnings.warn(DUMP_FILE_RENAME_MESSAGE, DeprecationWarning, stacklevel=2)
+            dump_file = data.pop("dump_file")
+            if dump_file is not None:
+                if data.get("xopt_dump_file") is not None:
+                    raise ValueError(
+                        "Cannot specify both 'dump_file' and 'xopt_dump_file'. "
+                        "Use 'xopt_dump_file' instead."
+                    )
+                data["xopt_dump_file"] = dump_file
+        return data
+
+    @property
+    def dump_file(self) -> Optional[str]:
+        warnings.warn(DUMP_FILE_RENAME_MESSAGE, DeprecationWarning, stacklevel=2)
+        return self.xopt_dump_file
+
+    @dump_file.setter
+    def dump_file(self, value: Optional[str]):
+        warnings.warn(DUMP_FILE_RENAME_MESSAGE, DeprecationWarning, stacklevel=2)
+        self.xopt_dump_file = value
+
     @property
     def n_data(self) -> int:
         if self.data is None:
@@ -440,9 +484,11 @@ class Xopt(XoptBaseModel):
 
         self.add_data(output_data)
 
-        # dump data to file if specified
-        if self.dump_file is not None:
+        # dump to file(s) if specified
+        if self.xopt_dump_file is not None:
             self.dump()
+        if self.data_dump_file is not None:
+            self.dump_data()
 
         return output_data
 
@@ -624,31 +670,58 @@ class Xopt(XoptBaseModel):
 
     def dump(self, file: str = None, **kwargs):
         """
-        Dump data to a file.
+        Dump the Xopt configuration and data to a YAML file.
+
+        Environment variables and `~` in the path are expanded.
 
         Parameters
         ----------
         file : str, optional
             The path to the file where the Xopt configuration will be dumped.
+            Defaults to the `xopt_dump_file` attribute.
         **kwargs
             Additional keyword arguments for customizing the dump.
 
         Raises
         ------
         ValueError
-            If no dump file is specified via argument or in the `dump_file` attribute.
+            If no dump file is specified via argument or in the `xopt_dump_file`
+            attribute.
 
         """
-        fname = file if file is not None else self.dump_file
+        fname = file if file is not None else self.xopt_dump_file
 
         if fname is None:
             raise ValueError(
-                "no dump file specified via argument or in `dump_file` attribute"
+                "no dump file specified via argument or in `xopt_dump_file` attribute"
             )
-        else:
-            with open(fname, "w") as f:
-                f.write(self.yaml(**kwargs))
-            logger.debug(f"Dumped state to YAML file: {fname}")
+
+        fname = os.path.expanduser(os.path.expandvars(fname))
+        with open(fname, "w") as f:
+            f.write(self.yaml(**kwargs))
+        logger.debug(f"Dumped state to YAML file: {fname}")
+
+    def dump_data(self):
+        """
+        Dump the evaluation data to the CSV file given by `data_dump_file`.
+
+        Environment variables and `~` in the path are expanded.
+
+        Raises
+        ------
+        ValueError
+            If no data dump file is specified in the `data_dump_file` attribute.
+
+        """
+        if self.data_dump_file is None:
+            raise ValueError(
+                "no data dump file specified in `data_dump_file` attribute"
+            )
+
+        fname = os.path.expanduser(os.path.expandvars(self.data_dump_file))
+        data = self.data if self.data is not None else pd.DataFrame()
+        data.to_csv(fname, index_label="xopt_index")
+        logger.debug(f"Dumped data to CSV file: {fname}")
 
     def dict(self, **kwargs) -> dict:
         """

{xopt-3.2.0 → xopt-3.2.2}/xopt/generators/bayesian/bax/algorithms.py

@@ -1,11 +1,10 @@
 from abc import ABC, abstractmethod
-from typing import ClassVar, List
+from typing import Any
 
 import torch
 from botorch.models.model import Model, ModelList
 from pydantic import BaseModel, ConfigDict, Field, PositiveInt, computed_field
 from torch import Tensor
-
 from xopt.pydantic import XoptBaseModel
 
 
@@ -56,7 +55,7 @@ class Algorithm(XoptBaseModel, ABC):
 
     Attributes
     ----------
-    name : ClassVar[str]
+    name : str
         The name of the algorithm.
     n_samples : PositiveInt
         Number of execution paths to generate.
@@ -69,12 +68,12 @@ class Algorithm(XoptBaseModel, ABC):
         Perform the virtual measurement and calculate objective values at the given inputs.
     """
 
-    name: ClassVar[str] = "base_algorithm"
+    name: str = Field(default="base_algorithm", frozen=True)
     n_samples: PositiveInt = Field(
         default=20, description="number of execution paths to generate"
     )
 
-    @computed_field
+    @computed_field  # type: ignore[prop-decorator]
     @property
     def class_path(self) -> str:
         return f"{self.__class__.__module__}.{self.__class__.__name__}"
@@ -105,7 +104,7 @@ class Algorithm(XoptBaseModel, ABC):
         x: Tensor,
         bounds: Tensor,
         n_samples: int,
-        tkwargs: dict = None,
+        tkwargs: dict[str, Any] | None = None,
     ) -> VirtualMeasurementResult:
         """
         Evaluate the virtual objective at the given inputs.
@@ -120,7 +119,7 @@ class Algorithm(XoptBaseModel, ABC):
             The bounds for the optimization.
         n_samples : int
             The number of samples to generate.
-        tkwargs : dict, optional
+        tkwargs : dict[str, Any] | None, optional
             Additional keyword arguments for the evaluation.
 
         Returns
@@ -148,7 +147,7 @@ class GridScanAlgorithm(Algorithm, ABC):
         Create a mesh for evaluating posteriors on.
     """
 
-    name = "grid_scan_algorithm"
+    name: str = Field(default="grid_scan", frozen=True)
     n_mesh_points: PositiveInt = Field(
         default=10, description="number of mesh points along each axis"
     )
@@ -200,13 +199,14 @@ class GridOptimize(GridScanAlgorithm):
 
     Methods
     -------
-    get_execution_paths(self, model: Model, bounds: Tensor) -> Tuple[Tensor, Tensor, Dict]
-        Get execution paths that minimize the objective function.
+    execute(self, model: Model, bounds: Tensor) -> GridOptimizeResult
+        Draw samples from the model, compute the sample virtual objective at grid points, and return sample optima.
     perform_virtual_measurement(self, model: Model, x: Tensor, bounds: Tensor, n_samples: int, tkwargs: dict = None) -> VirtualMeasurementResult
         Evaluate the virtual measurement and calculate objective values (samples).
     """
 
-    observable_names_ordered: List[str] = Field(
+    name: str = Field(default="grid_optimize", frozen=True)
+    observable_names_ordered: list[str] = Field(
         description="names of observable/objective models used in this algorithm",
     )
     minimize: bool = True
@@ -228,7 +228,7 @@ class GridOptimize(GridScanAlgorithm):
             Contains best_inputs, best_objective, input_execution_paths, output_execution_paths, and additional results.
         """
         # build evaluation mesh
-        test_points = self.create_mesh(bounds)
+        test_points: Tensor = self.create_mesh(bounds)
         if isinstance(model, ModelList):
             test_points = test_points.to(model.models[0].train_targets)
         else:
@@ -273,7 +273,7 @@ class GridOptimize(GridScanAlgorithm):
         x: Tensor,
         bounds: Tensor,
         n_samples: int,
-        tkwargs: dict = None,
+        tkwargs: dict[str, Any] | None = None,
     ) -> VirtualMeasurementResult:
         """
         Perform the virtual measurement (samples).
@@ -318,6 +318,7 @@ class CurvatureGridOptimize(GridOptimize):
         Perform the virtual measurement (samples) with curvature.
     """
 
+    name: str = Field(default="curvature_grid_optimize", frozen=True)
     use_mean: bool = False
 
     def perform_virtual_measurement(
@@ -326,7 +327,7 @@ class CurvatureGridOptimize(GridOptimize):
         x: Tensor,
         bounds: Tensor,
         n_samples: int,
-        tkwargs: dict = None,
+        tkwargs: dict[str, Any] | None = None,
     ) -> VirtualMeasurementResult:
         """
         Evaluate the virtual objective (samples) with curvature.

{xopt-3.2.0 → xopt-3.2.2}/xopt/generators/bayesian/bax_generator.py

@@ -1,10 +1,11 @@
-from copy import deepcopy
 import importlib
 import logging
 import pickle
-from typing import Dict, List, Optional
+from copy import deepcopy
+from typing import Any, Hashable, Optional, cast
 
 from botorch.models import ModelListGP, SingleTaskGP
+from gpytorch import Module
 from pydantic import (
     Field,
     SerializeAsAny,
@@ -12,12 +13,18 @@ from pydantic import (
     field_validator,
     model_validator,
 )
-
+from pydantic.fields import ModelPrivateAttr, PrivateAttr
+from xopt.errors import VOCSError
 from xopt.generators.bayesian.bax.acquisition import ModelListExpectedInformationGain
 from xopt.generators.bayesian.bax.algorithms import Algorithm, GridOptimize
 from xopt.generators.bayesian.bayesian_generator import BayesianGenerator
-from xopt.generators.bayesian.turbo import EntropyTurboController, SafetyTurboController
+from xopt.generators.bayesian.turbo import (
+    EntropyTurboController,
+    SafetyTurboController,
+    TurboController,
+)
 from xopt.generators.bayesian.utils import validate_turbo_controller_center
+from xopt.vocs import VOCS
 
 logger = logging.getLogger()
 
@@ -56,48 +63,89 @@ class BaxGenerator(BayesianGenerator):
     supports_no_objective: bool = True
     supports_discrete_variables: bool = False
     algorithm: SerializeAsAny[Algorithm] = Field(
-        description="algorithm evaluated in the BAX process"
+        default=GridOptimize(observable_names_ordered=[]),
+        description="algorithm evaluated in the BAX process",
     )
-    algorithm_results: Optional[Dict] = Field(
+    algorithm_results: Optional[dict] = Field(
         None, description="dictionary results from algorithm", exclude=True
     )
     algorithm_results_file: Optional[str] = Field(
         None, description="file name to save algorithm results at every step"
     )
     _n_calls: int = 0
-    _compatible_turbo_controllers = [EntropyTurboController, SafetyTurboController]
+    _compatible_turbo_controllers: list[type[TurboController]] = PrivateAttr(
+        default=[EntropyTurboController, SafetyTurboController]
+    )
 
     # NOTE: this is meant for use in Badger, TODO: add it to Xopt
-    _compatible_algorithms = [GridOptimize]
+    _compatible_algorithms: list[type[Algorithm]] = PrivateAttr(default=[GridOptimize])
 
     @model_validator(mode="after")
-    def validate_model_after(self):
+    def validate_model_after(self) -> "BaxGenerator":
         # validate turbo controller center if it exists
         validate_turbo_controller_center(self)
 
         return self
 
+    @field_validator("vocs", mode="after")
+    @classmethod
+    def validate_vocs(cls, v: VOCS, info: ValidationInfo) -> VOCS:
+        # Preserve inherited Bayesian VOCS validation behavior.
+        v = super().validate_vocs(v, info)
+
+        # assert that the generator had no objectives
+        if not v.n_objectives == 0:
+            raise VOCSError("BAX generator only supports problems with no objectives")
+
+        return v
+
     @field_validator("algorithm", mode="before")
-    def validate_algorithm(cls, v, info: ValidationInfo):
+    @classmethod
+    def validate_algorithm(cls, v: Any, info: ValidationInfo) -> Any:
         if isinstance(v, dict):
-            try:
+            if "class_path" in v:
                 class_path = v.pop("class_path")
                 module_name, class_name = class_path.rsplit(".", 1)
-            except KeyError:
-                raise ValueError("Algorithm dictionary must contain 'class_path' key")
-
-            try:
-                algorithm_class = getattr(
-                    importlib.import_module(module_name), class_name
+                try:
+                    algorithm_class = getattr(
+                        importlib.import_module(module_name), class_name
+                    )
+                except ModuleNotFoundError:
+                    raise ValueError(f"Cannot import '{module_name}.{class_name}'")
+            elif "name" in v:
+                name = v["name"]
+                algorithm_class = next(
+                    (
+                        c
+                        for c in cls._compatible_algorithms.default
+                        if c.model_fields["name"].default == name
+                    ),
+                    None,
+                )
+                if algorithm_class is None:
+                    raise ValueError(
+                        f"Unknown algorithm name '{name}'. "
+                        f"Provide one of {[c.model_fields['name'].default for c in cls._compatible_algorithms.default]} "
+                        f"or supply 'class_path'."
+                    )
+            else:
+                raise ValueError(
+                    "Algorithm dictionary must contain 'class_path' or 'name' key"
                 )
-            except ModuleNotFoundError:
-                raise ValueError(f"Cannot import '{module_name}.{class_name}'")
 
             v = algorithm_class.model_validate(v)
 
         return v
 
-    def generate(self, n_candidates: int) -> List[Dict]:
+    @classmethod
+    def get_compatible_algorithms(cls) -> list[type[Algorithm]]:
+        compatible = cls._compatible_algorithms
+        compatible_list: list[type[Algorithm]] = []
+        if isinstance(compatible, ModelPrivateAttr):
+            compatible_list = cast(list[type[Algorithm]], compatible.get_default())
+        return compatible_list
+
+    def generate(self, n_candidates: int) -> list[dict[Hashable, Any]]:
         """
         Generate a specified number of candidate samples.
 
@@ -108,19 +156,19 @@ class BaxGenerator(BayesianGenerator):
 
         Returns
         -------
-        List[Dict]
+        list[dict[Hashable, Any]]
             A list of dictionaries containing the generated samples.
         """
         self._n_calls += 1
         return super().generate(n_candidates)
 
-    def _get_acquisition(self, model) -> ModelListExpectedInformationGain:
+    def _get_acquisition(self, model: Module) -> ModelListExpectedInformationGain:
         """
         Get the acquisition function.
 
         Parameters
         ----------
-        model : Model
+        model : Module
             The model to use for the acquisition function.
 
         Returns

{xopt-3.2.0 → xopt-3.2.2}/xopt/generators/bayesian/bayesian_generator.py

@@ -1,39 +1,37 @@
 import logging
-from math import prod
 import os
 import time
 import warnings
-from copy import deepcopy
 from abc import ABC, abstractmethod
+from copy import deepcopy
 from itertools import islice, product
-from typing import Any, Dict, List, Optional, Union, cast
+from math import prod
+from typing import Any, Dict, Hashable, List, Optional, Union, cast
 
 import numpy as np
 import pandas as pd
 import torch
 from botorch.acquisition import (
-    FixedFeatureAcquisitionFunction,
-    qUpperConfidenceBound,
     AcquisitionFunction,
+    FixedFeatureAcquisitionFunction,
     MCAcquisitionObjective,
+    qUpperConfidenceBound,
 )
 from botorch.models.model import Model
 from botorch.sampling.get_sampler import get_sampler
+from gest_api.vocs import VOCS, DiscreteVariable, MaximizeObjective, MinimizeObjective
 from gpytorch import Module
 from pydantic import (
     Field,
-    field_validator,
     PositiveInt,
     SerializeAsAny,
+    field_validator,
     model_validator,
 )
-from pydantic.fields import PrivateAttr, ModelPrivateAttr
+from pydantic.fields import ModelPrivateAttr, PrivateAttr
 from pydantic_core.core_schema import ValidationInfo
 from torch import Tensor
-
-from gest_api.vocs import DiscreteVariable, MinimizeObjective, MaximizeObjective
-
-from xopt.errors import VOCSError, XoptError, FeasibilityError
+from xopt.errors import FeasibilityError, VOCSError, XoptError
 from xopt.generator import Generator
 from xopt.generators.bayesian.base_model import ModelConstructor
 from xopt.generators.bayesian.custom_botorch.constrained_acquisition import (
@@ -49,19 +47,19 @@ from xopt.generators.bayesian.models.standard import (
 )
 from xopt.generators.bayesian.models.time_dependent import TimeDependentModelConstructor
 from xopt.generators.bayesian.objectives import (
+    CustomXoptObjective,
     create_constraint_callables,
     create_mc_objective,
-    CustomXoptObjective,
 )
 from xopt.generators.bayesian.turbo import (
     TurboController,
 )
 from xopt.generators.bayesian.utils import (
+    compute_hypervolume_and_pf,
     interpolate_points,
     rectilinear_domain_union,
     set_botorch_weights,
     validate_turbo_controller_base,
-    compute_hypervolume_and_pf,
     validate_turbo_controller_center,
 )
 from xopt.generators.bayesian.visualize import visualize_generator_model
@@ -76,7 +74,6 @@ from xopt.vocs import (
     has_discrete_variables,
 )
 
-
 logger = logging.getLogger()
 
 # It seems pydantic v2 does not auto-register models anymore
@@ -203,6 +200,35 @@ class BayesianGenerator(Generator, ABC):
         default=[LBFGSOptimizer, GridOptimizer]
     )
 
+    @field_validator("vocs", mode="after")
+    @classmethod
+    def validate_vocs(cls, v: VOCS, info: ValidationInfo) -> VOCS:
+        if v.n_constraints > 0 and not info.data["supports_constraints"]:
+            raise VOCSError("this generator does not support constraints")
+
+        if has_discrete_variables(v) and not info.data["supports_discrete_variables"]:
+            raise VOCSError("this generator does not support discrete variables")
+
+        if (
+            cls._has_contextual_variables(v)
+            and not info.data["supports_contextual_variables"]
+        ):
+            raise VOCSError("this generator does not support contextual variables")
+
+        # assertion that at least one objective exists is done in model_validator below
+
+        if v.n_objectives == 1:
+            if not info.data["supports_single_objective"]:
+                raise VOCSError(
+                    "this generator does not support single objective optimization"
+                )
+        elif v.n_objectives > 1 and not info.data["supports_multi_objective"]:
+            raise VOCSError(
+                "this generator does not support multi-objective optimization"
+            )
+
+        return v
+
     @classmethod
     def get_compatible_turbo_controllers(cls) -> list[type[TurboController] | None]:
         compatible = cls._compatible_turbo_controllers
@@ -226,7 +252,7 @@ class BayesianGenerator(Generator, ABC):
 
     @field_validator("model", mode="before")
     @classmethod
-    def validate_torch_modules(cls, value: Any):
+    def validate_torch_modules(cls, value: Any) -> Any:
         if isinstance(value, str):
             if value.startswith("base64:"):
                 value = decode_torch_module(value)
@@ -238,7 +264,7 @@ class BayesianGenerator(Generator, ABC):
 
     @field_validator("gp_constructor", mode="before")
     @classmethod
-    def validate_gp_constructor(cls, value: Any):
+    def validate_gp_constructor(cls, value: Any) -> Any:
         constructor_dict = {
             "standard": StandardModelConstructor,
             "batched": BatchedModelConstructor,
@@ -266,7 +292,7 @@ class BayesianGenerator(Generator, ABC):
 
     @field_validator("numerical_optimizer", mode="before")
     @classmethod
-    def validate_numerical_optimizer(cls, value: Any):
+    def validate_numerical_optimizer(cls, value: Any) -> Any:
         optimizer_dict: dict[str, type[NumericalOptimizer]] = {
             "grid": GridOptimizer,
             "LBFGS": LBFGSOptimizer,
@@ -293,7 +319,7 @@ class BayesianGenerator(Generator, ABC):
 
     @field_validator("turbo_controller", mode="before")
     @classmethod
-    def validate_turbo_controller(cls, value: Any, info: ValidationInfo):
+    def validate_turbo_controller(cls, value: Any, info: ValidationInfo) -> Any:
         """note default behavior is no use of turbo"""
         if value is None:
             return value
@@ -313,7 +339,7 @@ class BayesianGenerator(Generator, ABC):
 
     @field_validator("computation_time", mode="before")
     @classmethod
-    def validate_computation_time(cls, value: Any):
+    def validate_computation_time(cls, value: Any) -> Any:
         if value is None:
             return value
         elif isinstance(value, pd.DataFrame):
@@ -328,7 +354,7 @@ class BayesianGenerator(Generator, ABC):
         return value
 
     @model_validator(mode="after")
-    def validate_model_after(self):
+    def validate_model_after(self) -> "BayesianGenerator":
         # validate turbo controller center if it exists
         validate_turbo_controller_center(self)
 
@@ -346,7 +372,7 @@ class BayesianGenerator(Generator, ABC):
 
         return self
 
-    def add_data(self, new_data: pd.DataFrame):
+    def add_data(self, new_data: pd.DataFrame) -> None:
         """
         Add new data to the generator for Bayesian Optimization.
 
@@ -361,7 +387,7 @@ class BayesianGenerator(Generator, ABC):
         """
         self.data = pd.concat([self.data, new_data], axis=0, ignore_index=True)
 
-    def generate(self, n_candidates: int):
+    def generate(self, n_candidates: int) -> list[dict[Hashable, Any]]:
         """
         Generate candidates using Bayesian Optimization.
 
@@ -372,7 +398,7 @@ class BayesianGenerator(Generator, ABC):
 
         Returns
         -------
-        List[Dict]
+        list[dict[Hashable, Any]]
             A list of dictionaries containing the generated candidates.
 
         Raises