code: def log_model(
      h2o_model,
      artifact_path,
      conda_env=None,
      code_paths=None,
      registered_model_name=None,
      signature: ModelSignature = None,
      input_example: ModelInputExample = None,
      pip_requirements=None,
      extra_pip_requirements=None,
      model_type="MOJO",
      extra_prediction_args=[],
      **kwargs,
  ):
      """
      Logs an H2O model as an MLflow artifact for the current run.
  
      :param h2o_model: H2O model to be saved.
      :param artifact_path: Run-relative artifact path.
      :param conda_env: {{ conda_env }}
      :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                         containing file dependencies). These files are *prepended* to the system
                         path when the model is loaded.
      :param registered_model_name: If given, create a model version under
                                    ``registered_model_name``, also creating a registered model if one
                                    with the given name does not exist.
  
      :param signature: {{ signature }}
      :param input_example: {{ input_example }}
      :param pip_requirements: {{ pip_requirements }}
      :param extra_pip_requirements: {{ extra_pip_requirements }}
      :param model_type: A flag deciding whether the model is MOJO or POJO.
      :param extra_prediction_args: A list of extra arguments for java scoring process. Possible values:
                                    --setConvertInvalidNum - Converts invalid numbers to NA
                                    --predictContributions - Returns also Shapley values a long with the predictions
                                    --predictCalibrated - Return also calibrated prediction values.
      :param kwargs: kwargs to pass to ``h2o.save_model`` method.
      :return: A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
               metadata of the logged model.
      """
      import h2o_mlflow_flavor
  
      return Model.log(
          artifact_path=artifact_path,
          flavor=h2o_mlflow_flavor,
          registered_model_name=registered_model_name,
          h2o_model=h2o_model,
          conda_env=conda_env,
          code_paths=code_paths,
          signature=signature,
          input_example=input_example,
          pip_requirements=pip_requirements,
          extra_pip_requirements=extra_pip_requirements,
          model_type=model_type,
          extra_prediction_args=extra_prediction_args,
          **kwargs,
      )
  
imports: import logging
  import os
  import tempfile
  import pandas
  import subprocess
  import sys
  import yaml
  import mlflow
  from mlflow import pyfunc
  from mlflow.models import Model
  from mlflow.models.model import MLMODEL_FILE_NAME
  from mlflow.models.utils import _save_example
  from mlflow.models import ModelSignature, ModelInputExample
  from mlflow.utils.environment import _CONDA_ENV_FILE_NAME, _CONSTRAINTS_FILE_NAME, _PYTHON_ENV_FILE_NAME, _REQUIREMENTS_FILE_NAME, _mlflow_conda_env, _process_conda_env, _process_pip_requirements, _PythonEnv, _validate_env_arguments
  from mlflow.utils.file_utils import write_to
  from mlflow.utils.model_utils import _get_flavor_configuration, _validate_and_copy_code_paths, _validate_and_prepare_target_save_path
  from mlflow.tracking.artifact_utils import _download_artifact_from_uri
  from mlflow.utils.requirements_utils import _get_pinned_requirement
label_desc: Use image node_id 8 for calling a global function with example usage: log_model(h2o_model, artifact_path, conda_env, code_paths, registered_model_name, signature, input_example, pip_requirements, extra_pip_requirements, model_type, extra_prediction_args) and returns: Model