code: def _get_input_names(data_dict):
      """Get names from dict
          Read in the data_dict to return the relevant file names. Will also
          add the default values if trDuration, isi, or burn_in haven't been set
  
      Parameters
      ----------
  
      data_dict : dict
          A dictionary to specify the parameters used for making data,
          specifying the following keys
          numTRs - int - Specify the number of time points
          multivariate_patterns - bool - Is the difference between conditions
          univariate (0) or multivariate (1)
          different_ROIs - bool - Are there different ROIs for each condition (
          1) or is it in the same ROI (0). If it is the same ROI and you are
          using univariate differences, the second condition will have a
          smaller evoked response than the other.
          event_duration - int - How long, in seconds, is each event
          scale_percentage - float - What is the percent signal change
          trDuration - float - How many seconds per volume
          save_dicom - bool - Save to data as a dicom (1) or numpy (0)
          save_realtime - bool - Do you want to save the data in real time (1)
          or as fast as possible (0)?
          isi - float - What is the time between each event (in seconds)
          burn_in - int - How long before the first event (in seconds)
  
      Returns
      ----------
  
      ROI_A_file : str
          Path to ROI for condition A
  
      ROI_B_file : str
          Path to ROI for condition B
  
      template_path : str
          Path to template file for data
  
      noise_dict_file : str
          Path to file containing parameters for noise simulation
  
      """
  
      # Load in the ROIs
      if data_dict.get("ROI_A_file") is None:
          vol = resource_stream(
              __name__, "sim_parameters/ROI_A.nii.gz"
          ).read()
          ROI_A_file = Nifti1Image.from_bytes(
              gzip.decompress(vol)
          ).get_fdata()
      else:
          ROI_A_file = data_dict["ROI_A_file"]
  
      if data_dict.get("ROI_B_file") is None:
          vol = resource_stream(
              __name__, "sim_parameters/ROI_B.nii.gz"
          ).read()
          ROI_B_file = Nifti1Image.from_bytes(
              gzip.decompress(vol)
          ).get_fdata()
      else:
          ROI_B_file = data_dict["ROI_B_file"]
  
      # Get the path to the template
      if data_dict.get("template_path") is None:
          vol = resource_stream(
              __name__, "sim_parameters/sub_template.nii.gz"
          ).read()
          template_path = Nifti1Image.from_bytes(
              gzip.decompress(vol)
          ).get_fdata()
      else:
          template_path = data_dict["template_path"]
  
      # Load in the noise dict if supplied
      if data_dict.get("noise_dict_file") is None:
          file = resource_stream(
              __name__, "sim_parameters/sub_noise_dict.txt"
          ).read()
          noise_dict_file = file
      else:
          noise_dict_file = data_dict["noise_dict_file"]
  
      # Return the paths
      return ROI_A_file, ROI_B_file, template_path, noise_dict_file
  
file_path: brainiak/brainiak/utils/fmrisim_real_time_generator.py
imports: import os
  import time
  import argparse
  import datetime
  import nibabel
  import numpy
  import pydicom
  from brainiak.utils import fmrisim
  import logging
  from pkg_resources import resource_stream
  from nibabel.nifti1 import Nifti1Image
  import gzip
label_desc: Use image node_id 3 for calling a global function with example usage: _get_input_names(data_dict) and returns: ROI_A_file,  ROI_B_file,  template_path,  noise_dict_file