code: def get_model_info(model_uri: str) -> ModelInfo:
      """
      Get metadata for the specified model, such as its input/output signature.
  
      :param model_uri: The location, in URI format, of the MLflow model. For example:
  
                        - ``/Users/me/path/to/local/model``
                        - ``relative/path/to/local/model``
                        - ``s3://my_bucket/path/to/model``
                        - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
                        - ``models:/<model_name>/<model_version>``
                        - ``models:/<model_name>/<stage>``
                        - ``mlflow-artifacts:/path/to/model``
  
                        For more information about supported URI schemes, see
                        `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
                        artifact-locations>`_.
  
      :return: A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
              metadata of the logged model.
  
      .. code-block:: python
              :caption: Example usage of get_model_info
  
              import mlflow.models
              import mlflow.sklearn
              from sklearn.ensemble import RandomForestRegressor
  
              with mlflow.start_run() as run:
                  params = {"n_estimators": 3, "random_state": 42}
                  X, y = [[0, 1]], [1]
                  signature = mlflow.models.infer_signature(X, y)
                  rfr = RandomForestRegressor(**params).fit(X, y)
                  mlflow.log_params(params)
                  mlflow.sklearn.log_model(rfr, artifact_path="sklearn-model", signature=signature)
  
              model_uri = f"runs:/{run.info.run_id}/sklearn-model"
              # Get model info with model_uri
              model_info = mlflow.models.get_model_info(model_uri)
              # Get model signature directly
              model_signature = model_info.signature
              assert model_signature == signature
      """
      from mlflow.pyfunc import _download_artifact_from_uri
  
      local_path = _download_artifact_from_uri(
          artifact_uri=model_uri, output_path=None
      )
      model_meta = Model.load(
          os.path.join(local_path, MLMODEL_FILE_NAME)
      )
      return ModelInfo(
          artifact_path=model_meta.artifact_path,
          flavors=model_meta.flavors,
          model_uri=model_uri,
          model_uuid=model_meta.model_uuid,
          run_id=model_meta.run_id,
          saved_input_example_info=model_meta.saved_input_example_info,
          signature_dict=model_meta.signature.to_dict()
          if model_meta.signature
          else None,
          signature=model_meta.signature,
          utc_time_created=model_meta.utc_time_created,
          mlflow_version=model_meta.mlflow_version,
          metadata=model_meta.metadata,
      )
  
imports: import json
  import logging
  import os
  import uuid
  import warnings
  from datetime import datetime
  from typing import Any, Callable, Dict, Optional, Union
  import yaml
  import mlflow
  from mlflow.artifacts import download_artifacts
  from mlflow.exceptions import MlflowException
  from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS
  from mlflow.tracking._tracking_service.utils import _resolve_tracking_uri
  from mlflow.utils.annotations import experimental
  from mlflow.utils.databricks_utils import get_databricks_runtime
  from mlflow.utils.file_utils import TempDir
  from mlflow.utils.uri import get_uri_scheme
label_desc: Use image node_id 1 for calling a global function with example usage: get_model_info(model_uri) and returns: ModelInfo