code: def test_BotorchMOOModel_with_chebyshev_scalarization_and_outcome_constraints(
      self,
      dtype: torch.dtype = torch.float,
      cuda: bool = False,
  ) -> None:
      tkwargs: Dict[str, Any] = {
          "device": torch.device("cuda")
          if cuda
          else torch.device("cpu"),
          "dtype": torch.float,
      }
      (
          Xs1,
          Ys1,
          Yvars1,
          bounds,
          tfs,
          feature_names,
          metric_names,
      ) = _get_torch_test_data(
          dtype=dtype, cuda=cuda, constant_noise=True
      )
      Xs2, Ys2, Yvars2, _, _, _, _ = _get_torch_test_data(
          dtype=dtype, cuda=cuda, constant_noise=True
      )
      training_data = [
          SupervisedDataset(
              X=Xs1[0],
              Y=Ys1[0],
              Yvar=Yvars1[0],
              feature_names=feature_names,
              outcome_names=metric_names,
          ),
          SupervisedDataset(
              X=Xs2[0],
              Y=Ys2[0],
              Yvar=Yvars2[0],
              feature_names=feature_names,
              outcome_names=metric_names,
          ),
      ]
  
      n = 2
      objective_weights = torch.tensor([1.0, 1.0], **tkwargs)
      obj_t = torch.tensor([1.0, 1.0], **tkwargs)
      model = MultiObjectiveBotorchModel(acqf_constructor=get_qLogNEI)
  
      search_space_digest = SearchSpaceDigest(
          feature_names=feature_names,
          bounds=bounds,
          task_features=tfs,
      )
      with mock.patch(FIT_MODEL_MO_PATH) as _mock_fit_model:
          model.fit(
              datasets=training_data,
              metric_names=metric_names,
              search_space_digest=search_space_digest,
          )
          _mock_fit_model.assert_called_once()
  
      torch_opt_config = TorchOptConfig(
          objective_weights=objective_weights,
          outcome_constraints=(
              torch.tensor([[1.0, 1.0]], **tkwargs),
              torch.tensor([[10.0]], **tkwargs),
          ),
          model_gen_options={
              "acquisition_function_kwargs": {
                  "chebyshev_scalarization": True
              },
          },
          objective_thresholds=obj_t,
      )
      with mock.patch(
          CHEBYSHEV_SCALARIZATION_PATH,
          wraps=get_chebyshev_scalarization,
      ) as _mock_chebyshev_scalarization:
          model.gen(
              n,
              search_space_digest=search_space_digest,
              torch_opt_config=torch_opt_config,
          )
          # get_chebyshev_scalarization should be called once for generated candidate.
          self.assertEqual(n, _mock_chebyshev_scalarization.call_count)
  
imports: import dataclasses
  from contextlib import ExitStack
  from typing import Any, Dict
  from unittest import mock
  import ax.models.torch.botorch_moo_defaults
  import botorch.utils.multi_objective.hypervolume
  import numpy
  import torch
  from ax.core.search_space import SearchSpaceDigest
  from ax.exceptions.core import AxError
  from ax.models.torch.botorch_defaults import get_qLogNEI
  from ax.models.torch.botorch_moo import MultiObjectiveBotorchModel
  from ax.models.torch.botorch_moo_defaults import get_EHVI, get_NEHVI, get_qLogEHVI, get_qLogNEHVI, infer_objective_thresholds
  from ax.models.torch.utils import HYPERSPHERE
  from ax.models.torch_base import TorchOptConfig
  from ax.utils.common.testutils import TestCase
  from ax.utils.testing.mock import fast_botorch_optimize
  from botorch.acquisition.multi_objective import logei, monte_carlo
  from botorch.models import ModelListGP
  from botorch.models.transforms.input import Warp
  from botorch.optim.optimize import optimize_acqf_list
  from botorch.sampling.normal import IIDNormalSampler
  from botorch.utils.datasets import SupervisedDataset
  from botorch.utils.multi_objective.hypervolume import infer_reference_point
  from botorch.utils.multi_objective.scalarization import get_chebyshev_scalarization
  from botorch.utils.testing import MockModel, MockPosterior
label_desc: Use image node_id 9 for calling the BotorchMOOModelTest obj's underlying member method code with example usage: obj.test_BotorchMOOModel_with_chebyshev_scalarization_and_outcome_constraints(dtype, cuda) without return types