class_docstr: The scenario manages environment variables and therefore gives context in which frame the optimization is performed.
  
  Parameters
  ----------
  configspace : ConfigurationSpace
      The configuration space from which to sample the configurations.
  name : str | None, defaults to None
      The name of the run. If no name is passed, SMAC generates a hash from the meta data.
      Specify this argument to identify your run easily.
  output_directory : Path, defaults to Path("smac3_output")
      The directory in which to save the output. The files are saved in `./output_directory/name/seed`.
  deterministic : bool, defaults to False
      If deterministic is set to true, only one seed is passed to the target function.
      Otherwise, multiple seeds (if n_seeds of the intensifier is greater than 1) are passed
      to the target function to ensure generalization.
  objectives : str | list[str] | None, defaults to "cost"
      The objective(s) to optimize. This argument is required for multi-objective optimization.
  crash_cost : float | list[float], defaults to np.inf
      Defines the cost for a failed trial. In case of multi-objective, each objective can be associated with
      a different cost.
  termination_cost_threshold : float | list[float], defaults to np.inf
      Defines a cost threshold when the optimization should stop. In case of multi-objective, each objective *must* be
      associated with a cost. The optimization stops when all objectives crossed the threshold.
  walltime_limit : float, defaults to np.inf
      The maximum time in seconds that SMAC is allowed to run.
  cputime_limit : float, defaults to np.inf
      The maximum CPU time in seconds that SMAC is allowed to run.
  trial_walltime_limit : float | None, defaults to None
      The maximum time in seconds that a trial is allowed to run. If not specified,
      no constraints are enforced. Otherwise, the process will be spawned by pynisher.
  trial_memory_limit : int | None, defaults to None
      The maximum memory in MB that a trial is allowed to use. If not specified,
      no constraints are enforced. Otherwise, the process will be spawned by pynisher.
  n_trials : int, defaults to 100
      The maximum number of trials (combination of configuration, seed, budget, and instance, depending on the task)
      to run.
  use_default_config: bool, defaults to False.
      If True, the configspace's default configuration is evaluated in the initial design.
      For historic benchmark reasons, this is False by default.
      Notice, that this will result in n_configs + 1 for the initial design. Respecting n_trials,
      this will result in one fewer evaluated configuration in the optimization.
  instances : list[str] | None, defaults to None
      Names of the instances to use. If None, no instances are used.
      Instances could be dataset names, seeds, subsets, etc.
  instance_features : dict[str, list[float]] | None, defaults to None
      Instances can be associated with features. For example, meta data of the dataset (mean, var, ...) can be
      incorporated which are then further used to expand the training data of the surrogate model.
  min_budget : float | int | None, defaults to None
      The minimum budget (epochs, subset size, number of instances, ...) that is used for the optimization.
      Use this argument if you use multi-fidelity or instance optimization.
  max_budget : float | int | None, defaults to None
      The maximum budget (epochs, subset size, number of instances, ...) that is used for the optimization.
      Use this argument if you use multi-fidelity or instance optimization.
  seed : int, defaults to 0
      The seed is used to make results reproducible. If seed is -1, SMAC will generate a random seed.
  n_workers : int, defaults to 1
      The number of workers to use for parallelization. If `n_workers` is greather than 1, SMAC will use
      Dask to parallelize the optimization.
docstr: Makes the scenario serializable.
docstr_tok: ["Makes","the","scenario","serializable","."]
code: def make_serializable(scenario: Scenario) -> dict[str, Any]:
      """Makes the scenario serializable."""
      s = copy.deepcopy(scenario.__dict__)
      del s["configspace"]
      s["output_directory"] = str(s["output_directory"])
  
      return json.loads(json.dumps(s))
  
imports: from __future__ import annotations
  from typing import Any
  import copy
  import hashlib
  import json
  import random
  from dataclasses import dataclass
  from pathlib import Path
  import numpy
  from ConfigSpace import ConfigurationSpace
  from ConfigSpace.read_and_write import json
  from smac.utils.logging import get_logger
label_desc: Use image node_id 8 for calling the Scenario obj's underlying member method code with example usage: obj.make_serializable(scenario) and returns: json