code: def run(
      run_id: str | None = None,
      init_id: str | None = None,
      final_id: str | None = None,
      meta_file: str | Sequence[str] | None = None,
      config_file: str | Sequence[str] | None = None,
      logging_file: str | None = None,
      tracking: str | dict | None = None,
      args_file: str | None = None,
      **override: Any,
  ) -> None:
      """
      Specify `config_file` to run monai bundle components and workflows.
  
      Typical usage examples:
  
      .. code-block:: bash
  
          # Execute this module as a CLI entry:
          python -m monai.bundle run --meta_file <meta path> --config_file <config path>
  
          # Execute with specified `run_id=training`:
          python -m monai.bundle run training --meta_file <meta path> --config_file <config path>
  
          # Execute with all specified `run_id=runtest`, `init_id=inittest`, `final_id=finaltest`:
          python -m monai.bundle run --run_id runtest --init_id inittest --final_id finaltest ...
  
          # Override config values at runtime by specifying the component id and its new value:
          python -m monai.bundle run --net#input_chns 1 ...
  
          # Override config values with another config file `/path/to/another.json`:
          python -m monai.bundle run --net %/path/to/another.json ...
  
          # Override config values with part content of another config file:
          python -m monai.bundle run --net %/data/other.json#net_arg ...
  
          # Set default args of `run` in a JSON / YAML file, help to record and simplify the command line.
          # Other args still can override the default args at runtime:
          python -m monai.bundle run --args_file "/workspace/data/args.json" --config_file <config path>
  
      Args:
          run_id: ID name of the expected config expression to run, default to "run".
              to run the config, the target config must contain this ID.
          init_id: ID name of the expected config expression to initialize before running, default to "initialize".
              it's optional for both configs and this `run` function.
          final_id: ID name of the expected config expression to finalize after running, default to "finalize".
              it's optional for both configs and this `run` function.
          meta_file: filepath of the metadata file, if it is a list of file paths, the content of them will be merged.
              Default to None.
          config_file: filepath of the config file, if `None`, must be provided in `args_file`.
              if it is a list of file paths, the content of them will be merged.
          logging_file: config file for `logging` module in the program. for more details:
              https://docs.python.org/3/library/logging.config.html#logging.config.fileConfig.
              Default to None.
          tracking: if not None, enable the experiment tracking at runtime with optionally configurable and extensible.
              if "mlflow", will add `MLFlowHandler` to the parsed bundle with default tracking settings,
              if other string, treat it as file path to load the tracking settings.
              if `dict`, treat it as tracking settings.
              will patch the target config content with `tracking handlers` and the top-level items of `configs`.
              for detailed usage examples, please check the tutorial:
              https://github.com/Project-MONAI/tutorials/blob/main/experiment_management/bundle_integrate_mlflow.ipynb.
          args_file: a JSON or YAML file to provide default values for `run_id`, `meta_file`,
              `config_file`, `logging`, and override pairs. so that the command line inputs can be simplified.
          override: id-value pairs to override or add the corresponding config content.
              e.g. ``--net#input_chns 42``, ``--net %/data/other.json#net_arg``.
  
      """
  
      workflow = create_workflow(
          config_file=config_file,
          args_file=args_file,
          meta_file=meta_file,
          logging_file=logging_file,
          init_id=init_id,
          run_id=run_id,
          final_id=final_id,
          tracking=tracking,
          **override,
      )
      workflow.run()
      workflow.finalize()
  
imports: from __future__ import annotations
  import ast
  import json
  import os
  import re
  import warnings
  from collections.abc import Mapping, Sequence
  from pathlib import Path
  from pydoc import locate
  from shutil import copyfile
  from textwrap import dedent
  from typing import Any, Callable
  import torch
  from torch.cuda import is_available
  from monai.apps.mmars.mmars import _get_all_ngc_models
  from monai.apps.utils import _basename, download_url, extractall, get_logger
  from monai.bundle.config_item import ConfigComponent
  from monai.bundle.config_parser import ConfigParser
  from monai.bundle.utils import DEFAULT_INFERENCE, DEFAULT_METADATA
  from monai.bundle.workflows import BundleWorkflow, ConfigWorkflow
  from monai.config import IgniteInfo, PathLike
  from monai.data import load_net_with_metadata, save_net_with_metadata
  from monai.networks import convert_to_onnx, convert_to_torchscript, convert_to_trt, copy_model_state, get_state_dict, save_state
  from monai.utils import check_parent_dir, deprecated_arg, ensure_tuple, get_equivalent_dtype, min_version, optional_import, pprint_edges
label_desc: Use image node_id 23 for calling a global function with example usage: run(run_id, init_id, final_id, meta_file, config_file, logging_file, tracking, args_file) without return types