class_docstr: Facade is an abstraction on top of the SMBO backend to organize the components of a Bayesian Optimization loop
  in a configurable and separable manner to suit the various needs of different (hyperparameter) optimization
  pipelines.
  
  With the exception to scenario and ``target_function``, which are expected of the user, the parameters ``model``,
  ``acquisition_function``, ``acquisition_maximizer``, ``initial_design``, ``random_design``, ``intensifier``,
  ``multi_objective_algorithm``, ``runhistory_encoder`` can either be explicitly specified in the subclasses'
  ``get_*`` methods (defining a specific BO pipeline) or be instantiated by the user to overwrite a pipeline
  components explicitly.
  
  Parameters
  ----------
  scenario : Scenario
      The scenario object, holding all environmental information.
  target_function : Callable | str | AbstractRunner
      This function is called internally to judge a trial's performance. If a string is passed,
      it is assumed to be a script. In this case, ``TargetFunctionScriptRunner`` is used to run the script.
  model : AbstractModel | None, defaults to None
      The surrogate model.
  acquisition_function : AbstractAcquisitionFunction | None, defaults to None
      The acquisition function.
  acquisition_maximizer : AbstractAcquisitionMaximizer | None, defaults to None
      The acquisition maximizer, deciding which configuration is most promising based on the surrogate model and
      acquisition function.
  initial_design : InitialDesign | None, defaults to None
      The sampled configurations from the initial design are evaluated before the Bayesian optimization loop starts.
  random_design : RandomDesign | None, defaults to None
      The random design is used in the acquisition maximizer, deciding whether the next configuration should be drawn
      from the acquisition function or randomly.
  intensifier : AbstractIntensifier | None, defaults to None
      The intensifier decides which trial (combination of configuration, seed, budget and instance) should be run
      next.
  multi_objective_algorithm : AbstractMultiObjectiveAlgorithm | None, defaults to None
      In case of multiple objectives, the objectives need to be interpreted so that an optimization is possible.
      The multi-objective algorithm takes care of that.
  runhistory_encoder : RunHistoryEncoder | None, defaults to None
      Based on the runhistory, the surrogate model is trained. However, the data first needs to be encoded, which
      is done by the runhistory encoder. For example, inactive hyperparameters need to be encoded or cost values
      can be log transformed.
  logging_level: int | Path | Literal[False] | None
      The level of logging (the lowest level 0 indicates the debug level). If a path is passed, a yaml file is
      expected with the logging configuration. If nothing is passed, the default logging.yml from SMAC is used.
      If False is passed, SMAC will not do any customization of the logging setup and the responsibility is left
      to the user.
  callbacks: list[Callback], defaults to []
      Callbacks, which are incorporated into the optimization loop.
  overwrite: bool, defaults to False
      When True, overwrites the run results if a previous run is found that is
      consistent in the meta data with the current setup. When False and a previous run is found that is
      consistent in the meta data, the run is continued. When False and a previous run is found that is
      not consistent in the meta data, the the user is asked for the exact behaviour (overwrite completely
      or rename old run first).
  dask_client: Client | None, defaults to None
      User-created dask client, which can be used to start a dask cluster and then attach SMAC to it. This will not
      be closed automatically and will have to be closed manually if provided explicitly. If none is provided
      (default), a local one will be created for you and closed upon completion.
docstr: Asks the intensifier for the next trial.
docstr_tok: ["Asks","the","intensifier","for","the","next","trial","."]
code: def ask(self) -> TrialInfo:
      """Asks the intensifier for the next trial."""
      return self._optimizer.ask()
  
imports: from __future__ import annotations
  from abc import abstractmethod
  from typing import Any, Callable
  from pathlib import Path
  import joblib
  from ConfigSpace import Configuration
  from dask.distributed import Client
  from typing_extensions import Literal
  import smac
  from smac.acquisition.function.abstract_acquisition_function import AbstractAcquisitionFunction
  from smac.acquisition.maximizer.abstract_acqusition_maximizer import AbstractAcquisitionMaximizer
  from smac.callback.callback import Callback
  from smac.initial_design.abstract_initial_design import AbstractInitialDesign
  from smac.intensifier.abstract_intensifier import AbstractIntensifier
  from smac.main.config_selector import ConfigSelector
  from smac.main.smbo import SMBO
  from smac.model.abstract_model import AbstractModel
  from smac.multi_objective.abstract_multi_objective_algorithm import AbstractMultiObjectiveAlgorithm
  from smac.random_design.abstract_random_design import AbstractRandomDesign
  from smac.runhistory.dataclasses import TrialInfo, TrialValue
  from smac.runhistory.encoder.abstract_encoder import AbstractRunHistoryEncoder
  from smac.runhistory.runhistory import RunHistory
  from smac.runner.abstract_runner import AbstractRunner
  from smac.runner.dask_runner import DaskParallelRunner
  from smac.runner.target_function_runner import TargetFunctionRunner
  from smac.runner.target_function_script_runner import TargetFunctionScriptRunner
  from smac.scenario import Scenario
  from smac.utils.logging import get_logger, setup_logging
label_desc: Use image node_id 7 for calling the AbstractFacade obj's underlying member method code with example usage: obj.ask() and returns: self