code: def run():
      """
      meta_parser is first used to find out location
      of the configuration file. Based on the application_name
      or meta_parser.prog name, the section parsers are organised
      to find system parameters and application specific
      parameters.
  
      :return: system parameters is a group of parameters including
          SYSTEM_SECTIONS and app_module.REQUIRED_CONFIG_SECTION
          input_data_args is a group of input data sources to be
          used by niftynet.io.ImageReader
      """
      meta_parser = argparse.ArgumentParser(
          description="Launch a NiftyNet application.",
          formatter_class=argparse.RawDescriptionHelpFormatter,
          epilog=textwrap.dedent(EPILOG_STRING),
      )
      version_string = get_niftynet_version_string()
      meta_parser.add_argument(
          "action",
          help="train networks, run inferences "
          "or evaluate inferences",
          metavar="ACTION",
          choices=list(ACTIONS),
      )
      meta_parser.add_argument(
          "-v", "--version", action="version", version=version_string
      )
      meta_parser.add_argument(
          "-c",
          "--conf",
          help="specify configurations from a file",
          metavar="CONFIG_FILE",
      )
      meta_parser.add_argument(
          "-a",
          "--application_name",
          help="specify an application module name",
          metavar="APPLICATION_NAME",
          default="",
      )
  
      meta_args, args_from_cmdline = meta_parser.parse_known_args()
      print(version_string)
  
      # read configurations, to be parsed by sections
      config_file_name = __resolve_config_file_path(meta_args.conf)
      config = NiftyNetLaunchConfig()
      config.read([config_file_name])
  
      # infer application name from command
      app_name = None
      try:
          parser_prog = meta_parser.prog.replace(".py", "")
          app_name = (
              parser_prog
              if parser_prog in SUPPORTED_APP
              else meta_args.application_name
          )
          assert app_name
      except (AttributeError, AssertionError):
          raise ValueError(
              "\nUnknown application {}, or did you forget '-a' "
              "command argument?{}".format(app_name, EPILOG_STRING)
          )
  
      # load application by name
      app_module = ApplicationFactory.create(app_name)
      try:
          assert app_module.REQUIRED_CONFIG_SECTION, (
              "\nREQUIRED_CONFIG_SECTION should be static variable "
              "in {}".format(app_module)
          )
          has_section_in_config(
              config, app_module.REQUIRED_CONFIG_SECTION
          )
      except AttributeError:
          raise AttributeError(
              "Application code doesn't have REQUIRED_CONFIG_SECTION property. "
              "{} should be an instance of "
              "niftynet.application.base_application".format(app_module)
          )
      except ValueError:
          raise ValueError(
              "\n{} requires [{}] section in the config file.{}".format(
                  app_name,
                  app_module.REQUIRED_CONFIG_SECTION,
                  EPILOG_STRING,
              )
          )
  
      # check keywords in configuration file
      _check_config_file_keywords(config)
  
      # using configuration as default, and parsing all command line arguments
      # command line args override the configure file options
      all_args = {}
      for section in config.sections():
          # try to rename user-specified sections for consistency
          section = standardise_section_name(config, section)
          section_defaults = dict(config.items(section))
          section_args, args_from_cmdline = _parse_arguments_by_section(
              [],
              section,
              section_defaults,
              args_from_cmdline,
              app_module.REQUIRED_CONFIG_SECTION,
          )
          all_args[section] = section_args
  
      # check if any args from command line not recognised
      _check_cmd_remaining_keywords(list(args_from_cmdline))
  
      # split parsed results in all_args
      # into dictionaries of system_args and input_data_args
      system_args, input_data_args = {}, {}
      for section in all_args:
          # copy system default sections to ``system_args``
          if section in SYSTEM_SECTIONS:
              system_args[section] = all_args[section]
              continue
  
          # copy application specific sections to ``system_args``
          if section == app_module.REQUIRED_CONFIG_SECTION:
              system_args["CUSTOM"] = all_args[section]
              vars(system_args["CUSTOM"])["name"] = app_name
              continue
  
          # copy non-default sections to ``input_data_args``
          input_data_args[section] = all_args[section]
  
          # set the output path of csv list if not exists
          try:
              csv_path = resolve_file_name(
                  input_data_args[section].csv_file,
                  (os.path.dirname(config_file_name), NIFTYNET_HOME),
              )
              input_data_args[section].csv_file = csv_path
              # don't search files if csv specified in config
              try:
                  delattr(input_data_args[section], "path_to_search")
              except AttributeError:
                  pass
          except (IOError, TypeError):
              input_data_args[section].csv_file = ""
  
      # preserve ``config_file`` and ``action parameter`` from the meta_args
      system_args["CONFIG_FILE"] = argparse.Namespace(
          path=config_file_name
      )
      # mapping the captured action argument to a string in ACTIONS
      system_args["SYSTEM"].action = look_up_operations(
          meta_args.action, ACTIONS
      )
      if not system_args["SYSTEM"].model_dir:
          system_args["SYSTEM"].model_dir = os.path.join(
              os.path.dirname(config_file_name), "model"
          )
      return system_args, input_data_args
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import argparse
  import os
  import textwrap
  from niftynet.engine.signal import TRAIN, INFER, EVAL
  from niftynet.utilities.util_common import look_up_operations
  from niftynet.engine.application_factory import ApplicationFactory
  from niftynet.engine.application_factory import SUPPORTED_APP
  from niftynet.io.misc_io import resolve_file_name
  from niftynet.utilities.niftynet_global_config import NiftyNetGlobalConfig
  from niftynet.utilities import NiftyNetLaunchConfig
  from niftynet.utilities.user_parameters_custom import SUPPORTED_ARG_SECTIONS
  from niftynet.utilities.user_parameters_custom import add_customised_args
  from niftynet.utilities.user_parameters_default import SUPPORTED_DEFAULT_SECTIONS
  from niftynet.utilities.user_parameters_default import add_input_data_args
  from niftynet.utilities.user_parameters_helper import has_section_in_config
  from niftynet.utilities.user_parameters_helper import standardise_section_name
  from niftynet.utilities.util_common import damerau_levenshtein_distance
  from niftynet.utilities.versioning import get_niftynet_version_string
label_desc: Use image node_id 2 for calling a global function with example usage: run() and returns: system_args,  input_data_args