code: def import_model(
      name: Tag | str,
      model_uri: str,
      *,
      signatures: dict[str, ModelSignature]
      | dict[str, ModelSignatureDict]
      | None = None,
      labels: dict[str, str] | None = None,
      custom_objects: dict[str, t.Any] | None = None,
      external_modules: t.List[ModuleType] | None = None,
      metadata: dict[str, t.Any] | None = None,
      # ...
  ) -> bentoml.Model:
      """
      Import MLflow model from a artifact URI to the BentoML model store.
  
      Args:
          name:
              The name to give to the model in the BentoML store. This must be a valid
              :obj:`~bentoml.Tag` name.
          model_uri:
              The MLflow model to be saved.
          signatures:
              Signatures of predict methods to be used. If not provided, the signatures
              default to {"predict": {"batchable": False}}. See
              :obj:`~bentoml.types.ModelSignature` for more details.
          labels:
              A default set of management labels to be associated with the model. For
              example: ``{"training-set": "data-v1"}``.
          custom_objects:
              Custom objects to be saved with the model. An example is
              ``{"my-normalizer": normalizer}``. Custom objects are serialized with
              cloudpickle.
          metadata:
              Metadata to be associated with the model. An example is ``{"param_a": .2}``.
  
              Metadata is intended for display in a model management UI and therefore all
              values in metadata dictionary must be a primitive Python type, such as
              ``str`` or ``int``.
  
      Returns:
          A :obj:`~bentoml.Model` instance referencing a saved model in the local BentoML
          model store.
  
      Example:
  
      .. code-block:: python
  
          import bentoml
  
          bentoml.mlflow.import_model(
              'my_mlflow_model',
              model_uri="runs:/<mlflow_run_id>/run-relative/path/to/model",
              signatures={
                  "predict": {"batchable": True},
              }
          )
      """
      context = ModelContext(
          framework_name="mlflow",
          framework_versions={"mlflow": mlflow.__version__},
      )
  
      if signatures is None:
          signatures = {
              "predict": {"batchable": False},
          }
          logger.info(
              'Using the default model signature for MLflow (%s) for model "%s".',
              signatures,
              name,
          )
      if len(signatures) != 1 or "predict" not in signatures:
          raise BentoMLException(
              f"MLflow pyfunc model support only the `predict` method, signatures={signatures} is not supported"
          )
  
      with bentoml.models.create(
          name,
          module=MODULE_NAME,
          api_version=API_VERSION,
          signatures=signatures,
          labels=labels,
          options=None,
          custom_objects=custom_objects,
          external_modules=external_modules,
          metadata=metadata,
          context=context,
      ) as bento_model:
          from mlflow.models import Model as MLflowModel
          from mlflow.models.model import MLMODEL_FILE_NAME
          from mlflow.pyfunc import FLAVOR_NAME as PYFUNC_FLAVOR_NAME
  
          # Explicitly provide a destination dir to mlflow so that we don't
          # accidentially download into the root of the bento model temp dir
          # (using a model:/ url can cause this)
          download_dir = tempfile.mkdtemp(dir=bento_model.path)
  
          try:
              # Prefer public API download_artifacts introduced in MLflow 1.25
              from mlflow.artifacts import download_artifacts
  
              local_path = download_artifacts(
                  artifact_uri=model_uri, dst_path=download_dir
              )
          except (ModuleNotFoundError, ImportError):
              # For MLflow < 1.25
              from mlflow.tracking.artifact_utils import (
                  _download_artifact_from_uri,
              )
  
              local_path: str = _download_artifact_from_uri(
                  artifact_uri=model_uri, output_path=download_dir
              )
          finally:
              mlflow_model_path = bento_model.path_of(
                  MLFLOW_MODEL_FOLDER
              )
              # Rename model folder from original artifact name to fixed "mlflow_model"
              shutil.move(local_path, mlflow_model_path)  # type: ignore (local_path is bound)
              # Remove the tempdir if it still exists.
              # NOTE for models:/ uri downloads, the download_dir itself is actually renamed
              # in the previous line, not a subdir of download_dir like other methods.
              # Calling rmtree unchecked will lead to models:/ downloads failing
              if os.path.exists(download_dir):
                  shutil.rmtree(download_dir)
  
          mlflow_model_file = os.path.join(
              mlflow_model_path, MLMODEL_FILE_NAME
          )
  
          if not os.path.exists(mlflow_model_file):
              raise BentoMLException(
                  f'artifact "{model_uri}" is not a MLflow model'
              )
  
          model_meta = MLflowModel.load(mlflow_model_file)
          if PYFUNC_FLAVOR_NAME not in model_meta.flavors:
              raise BentoMLException(
                  f'MLflow model "{model_uri}" does not support the required python_function flavor'
              )
  
          return bento_model
  
file_path: BentoML/grpc-client/bentoml/_internal/frameworks/mlflow.py
imports: from __future__ import annotations
  import logging
  import os
  import shutil
  import tempfile
  import typing
  from typing import TYPE_CHECKING
  import bentoml
  from bentoml import Tag
  from bentoml.exceptions import BentoMLException
  from bentoml.exceptions import MissingDependencyException
  from bentoml.exceptions import NotFound
  from bentoml.models import ModelContext
label_desc: Use image node_id 3 for calling a global function with example usage: import_model(name, model_uri) and returns: bento_model