code: def load_model(model_uri, dst_path=None):
      """
      Load a ``pmdarima`` ``ARIMA`` model or ``Pipeline`` object from a local file or a run.
  
      Args:
          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``
              - ``mlflow-artifacts:/path/to/model``
              For more information about supported URI schemes, see
              `Referencing Artifacts <https://www.mlflow.org/docs/latest/tracking.html#
              artifact-locations>`_.
          dst_path: The local filesystem path to which to download the model artifact.
              This directory must already exist. If unspecified, a local output
              path will be created.
  
      Returns:
          A ``pmdarima`` model instance
  
      .. code-block:: python
          :caption: Example
  
          import pandas as pd
          import mlflow
          from mlflow.models import infer_signature
          import pmdarima
          from pmdarima.metrics import smape
  
          # Specify locations of source data and the model artifact
          SOURCE_DATA = "https://raw.githubusercontent.com/facebook/prophet/master/examples/example_retail_sales.csv"
          ARTIFACT_PATH = "model"
  
          # Read data and recode columns
          sales_data = pd.read_csv(SOURCE_DATA)
          sales_data.rename(columns={"y": "sales", "ds": "date"}, inplace=True)
  
          # Split the data into train/test
          train_size = int(0.8 * len(sales_data))
          train, test = sales_data[:train_size], sales_data[train_size:]
  
          with mlflow.start_run():
              # Create the model
              model = pmdarima.auto_arima(train["sales"], seasonal=True, m=12)
  
              # Calculate metrics
              prediction = model.predict(n_periods=len(test))
              metrics = {"smape": smape(test["sales"], prediction)}
  
              # Infer signature
              input_sample = pd.DataFrame(train["sales"])
              output_sample = pd.DataFrame(model.predict(n_periods=5))
              signature = infer_signature(input_sample, output_sample)
  
              # Log model
              input_example = input_sample.head()
              mlflow.pmdarima.log_model(
                  model, ARTIFACT_PATH, signature=signature, input_example=input_example
              )
  
              # Get the model URI for loading
              model_uri = mlflow.get_artifact_uri(ARTIFACT_PATH)
  
          # Load the model
          loaded_model = mlflow.pmdarima.load_model(model_uri)
          # Forecast for the next 60 days
          forecast = loaded_model.predict(n_periods=60)
          print(f"forecast: {forecast}")
  
      .. code-block:: text
          :caption: Output
  
          forecast:
          234    382452.397246
          235    380639.458720
          236    359805.611219
          ...
      """
  
      local_model_path = _download_artifact_from_uri(
          artifact_uri=model_uri, output_path=dst_path
      )
      flavor_conf = _get_flavor_configuration(
          model_path=local_model_path, flavor_name=FLAVOR_NAME
      )
      _add_code_from_conf_to_system_path(local_model_path, flavor_conf)
      pmdarima_model_file_path = os.path.join(
          local_model_path,
          flavor_conf.get(_MODEL_BINARY_KEY, _MODEL_BINARY_FILE_NAME),
      )
  
      return _load_model(pmdarima_model_file_path)
  
imports: import logging
  import os
  import pickle
  import warnings
  from typing import Any, Dict, Optional
  import pandas
  import yaml
  from packaging.version import Version
  import mlflow
  from mlflow import pyfunc
  from mlflow.exceptions import MlflowException
  from mlflow.models import Model, ModelInputExample, ModelSignature
  from mlflow.models.model import MLMODEL_FILE_NAME
  from mlflow.models.signature import _infer_signature_from_input_example
  from mlflow.models.utils import _save_example
  from mlflow.protos.databricks_pb2 import INVALID_PARAMETER_VALUE
  from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS
  from mlflow.tracking.artifact_utils import _download_artifact_from_uri
  from mlflow.utils.docstring_utils import LOG_MODEL_PARAM_DOCS, format_docstring
  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 get_total_file_size, write_to
  from mlflow.utils.model_utils import _add_code_from_conf_to_system_path, _get_flavor_configuration, _validate_and_copy_code_paths, _validate_and_prepare_target_save_path
  from mlflow.utils.requirements_utils import _get_pinned_requirement
label_desc: Use image node_id 5 for calling a global function with example usage: load_model(model_uri, dst_path) and returns: _load_model