class_docstr: Base class for H2O Estimators.
  
  H2O Estimators implement the following methods for model construction:
  
      - ``start()`` - Top-level user-facing API for asynchronous model build
      - ``join()``  - Top-level user-facing API for blocking on async model build
      - ``train()`` - Top-level user-facing API for model building.
      - ``fit()`` - Used by scikit-learn.
  
  Because H2OEstimator instances are instances of ModelBase, these objects can use the H2O model API.
code: def _make_parms(
      self,
      x=None,
      y=None,
      training_frame=None,
      offset_column=None,
      fold_column=None,
      weights_column=None,
      validation_frame=None,
      max_runtime_secs=None,
      ignored_columns=None,
      model_id=None,
      verbose=False,
      extend_parms_fn=None,
  ):
      has_default_training_frame = (
          hasattr(self, "training_frame")
          and self.training_frame is not None
      )
      training_frame = H2OFrame._validate(
          training_frame,
          "training_frame",
          required=self._options_.get("requires_training_frame", True)
          and not has_default_training_frame,
      )
      validation_frame = H2OFrame._validate(
          validation_frame, "validation_frame"
      )
      assert_is_type(y, None, int, str)
      assert_is_type(
          x, None, int, str, ModelBase, [str, int], {str, int}
      )
      assert_is_type(ignored_columns, None, [str, int], {str, int})
      assert_is_type(offset_column, None, int, str)
      assert_is_type(fold_column, None, int, str)
      assert_is_type(weights_column, None, int, str)
      assert_is_type(max_runtime_secs, None, numeric)
      assert_is_type(model_id, None, str)
      assert_is_type(verbose, bool)
      assert_is_type(extend_parms_fn, None, FunctionType)
  
      override_default_training_frame = training_frame is not None
      if not override_default_training_frame:
          self._verify_training_frame_params(
              offset_column,
              fold_column,
              weights_column,
              validation_frame,
          )
          training_frame = (
              self.training_frame
              if has_default_training_frame
              else None
          )
  
      if verbose and not self._options_.get("verbose", False):
          raise H2OValueError(
              "Verbose mode is not available for %s"
              % self.__class__.__name__
          )
      parms = self._parms.copy()
      names = LookupSeq(
          training_frame.names if training_frame is not None else []
      )
      ncols = training_frame.ncols if training_frame is not None else 0
      types = training_frame.types if training_frame is not None else {}
  
      if self.supervised_learning:
          if y is None:
              y = "response"
          if is_type(y, int):
              if not (-ncols <= y < ncols):
                  raise H2OValueError(
                      "Column %d does not exist in the training frame"
                      % y
                  )
              y = names[y]
          else:
              if y not in names:
                  raise H2OValueError(
                      "Column %s does not exist in the training frame"
                      % y
                  )
          self._estimator_type = (
              "classifier" if types[y] == "enum" else "regressor"
          )
      else:
          # If `y` is provided for an unsupervised model we'll simply ignore
          # it. This way an unsupervised model can be used as a step in
          # sklearn's pipeline.
          y = None
          self._estimator_type = "unsupervised"
  
      if override_default_training_frame:
          assert_is_type(y, str, None)
          ignored_columns_set = set()
          if ignored_columns is None and "ignored_columns" in parms:
              ignored_columns = parms["ignored_columns"]
          if ignored_columns is not None:
              if x is not None:
                  raise H2OValueError(
                      "Properties x and ignored_columns cannot be specified simultaneously"
                  )
              for ic in ignored_columns:
                  if is_type(ic, int):
                      if not (-ncols <= ic < ncols):
                          raise H2OValueError(
                              "Column %d does not exist in the training frame"
                              % ic
                          )
                      ignored_columns_set.add(names[ic])
                  else:
                      if ic not in names:
                          raise H2OValueError(
                              "Column %s not in the training frame" % ic
                          )
                      ignored_columns_set.add(ic)
          if x is None:
              xset = names.set() - {y} - ignored_columns_set
          elif isinstance(x, ModelBase) and hasattr(
              x, "_extract_x_from_model"
          ):
              xset = x._extract_x_from_model()
          else:
              xset = set()
              if is_type(x, int, str):
                  x = [x]
              for xi in x:
                  if is_type(xi, int):
                      if not (-ncols <= xi < ncols):
                          raise H2OValueError(
                              "Column %d does not exist in the training frame"
                              % xi
                          )
                      xset.add(names[xi])
                  else:
                      if xi not in names:
                          raise H2OValueError(
                              "Column %s not in the training frame" % xi
                          )
                      xset.add(xi)
          x = list(xset)
          self._check_and_save_parm(
              parms, "offset_column", offset_column
          )
          self._check_and_save_parm(
              parms, "weights_column", weights_column
          )
          self._check_and_save_parm(parms, "fold_column", fold_column)
  
      if max_runtime_secs is not None:
          parms["max_runtime_secs"] = max_runtime_secs
  
      # Overwrites the model_id parameter only if model_id is passed
      if model_id is not None:
          parms["model_id"] = model_id
      if override_default_training_frame:
          parms["training_frame"] = training_frame
          offset = parms["offset_column"]
          folds = parms["fold_column"]
          weights = parms["weights_column"]
  
      if validation_frame is not None:
          parms["validation_frame"] = validation_frame
  
      if is_type(y, int):
          y = names[y]
      if y is not None:
          parms["response_column"] = y
      if not isinstance(x, (list, tuple)):
          x = [x]
      if len(x) > 0 and is_type(x[0], int):
          x = [names[i] for i in x]
      if override_default_training_frame:
          ignored_columns = list(
              names.set() - set(x + [y, offset, folds, weights])
          )
          parms["ignored_columns"] = (
              None
              if len(ignored_columns) == 0
              else [quoted(col) for col in ignored_columns]
          )
      parms["interactions"] = (
          None
          if "interactions" not in parms
          or parms["interactions"] is None
          else [quoted(col) for col in parms["interactions"]]
      )
      parms["interaction_pairs"] = (
          None
          if "interaction_pairs" not in parms
          or parms["interaction_pairs"] is None
          else [
              tuple(map(quoted, ip))
              for ip in parms["interaction_pairs"]
          ]
      )
  
      # internal hook allowing subclasses to extend train parms
      if extend_parms_fn is not None:
          extend_parms_fn(parms)
  
      parms = {k: H2OEstimator._keyify(v) for k, v in parms.items()}
      if "r2" in (parms.get("stopping_metric") or []):
          raise H2OValueError(
              "r2 cannot be used as an early stopping_metric yet.  Check this issue https://github.com/h2oai/h2o-3/issues/12248 for progress."
          )
      return parms
  
imports: from h2o.utils.compatibility import *
  from datetime import datetime
  import inspect
  import warnings
  import h2o
  from h2o.base import Keyed
  from h2o.exceptions import H2OValueError, H2OResponseError
  from h2o.frame import H2OFrame
  from h2o.job import H2OJob
  from h2o.utils.mixin import assign, load_ext, mixin
  from h2o.utils.shared_utils import quoted, LookupSeq
  from h2o.utils.typechecks import assert_is_type, is_type, numeric, FunctionType
  from h2o.model import ModelBase, H2OSegmentModels
  from h2o.model.models import *
  from h2o.model.metrics import *
label_desc: Use image node_id 7 for calling the H2OEstimator obj's underlying member method code with example usage: obj._make_parms(x, y, training_frame, offset_column, fold_column, weights_column, validation_frame, max_runtime_secs, ignored_columns, model_id, verbose, extend_parms_fn) and returns: parms