code: def data_iterator_concat_datasets(
      data_source_list,
      batch_size,
      shuffle=False,
      rng=None,
      use_thread=True,
      with_memory_cache=True,
      with_file_cache=False,
      cache_dir=None,
      epoch_begin_callbacks=[],
      epoch_end_callbacks=[],
      stop_exhausted=False,
  ):
      """data_iterator_concat_datasets
      Get data from multiple datasets.
  
      For example,
  
      .. code-block:: python
  
          batch = data_iterator_concat_datasets([DataSource0, DataSource1, ...], batch_size)
  
      Args:
          data_source_list (list of DataSource): list of datasets.
          batch_size (int): Size of data unit.
          shuffle (bool):
               Indicates whether the dataset is shuffled or not.
               Default value is False.
          rng (None or :obj:`numpy.random.RandomState`): Numpy random number
              generator.
          use_thread (bool):
              If ``use_thread`` is set to True, iterator will use another thread to
              fetch data. If ``use_thread`` is set to False, iterator will use
              current thread to fetch data.
          with_memory_cache (bool):
              If ``True``, use :py:class:`.data_source.DataSourceWithMemoryCache`
              to wrap ``data_source``. It is a good idea to set this as true unless
              data_source provides on-memory data.
              Default value is True.
          with_file_cache (bool):
              If ``True``, use :py:class:`.data_source.DataSourceWithFileCache`
              to wrap ``data_source``.
              If ``data_source`` is slow, enabling this option a is good idea.
              Default value is False.
          cache_dir (str):
              Location of file_cache.
              If this value is None, :py:class:`.data_source.DataSourceWithFileCache`
              creates file caches implicitly on temporary directory and erases them all
              when data_iterator is finished.
              Otherwise, :py:class:`.data_source.DataSourceWithFileCache` keeps created cache.
              Default is None.
          epoch_begin_callbacks (list of functions): An item is a function
              which takes an epoch index as an argument. These are called
              at the beginning of an epoch.
          epoch_end_callbacks (list of functions): An item is a function
              which takes an epoch index as an argument. These are called
              at the end of an epoch.
          stop_exhausted (bool): If ``stop_exhausted`` is set to False, iterator will be reset
              so that iteration can be continued. If ``stop_exhausted`` is set to True, iterator
              will raise StopIteration to stop the loop.
  
  
      Returns:
          :py:class:`DataIterator <nnabla.utils.data_iterator.DataIterator>`:
              Instance of DataIterator
      """
      ds = ConcatDataSource(data_source_list, shuffle=shuffle, rng=rng)
      return data_iterator(
          ds,
          use_thread=use_thread,
          batch_size=batch_size,
          with_memory_cache=with_memory_cache,
          with_file_cache=with_file_cache,
          epoch_begin_callbacks=epoch_begin_callbacks,
          epoch_end_callbacks=epoch_end_callbacks,
          stop_exhausted=stop_exhausted,
      )
  
imports: import atexit
  import threading
  import queue
  import numpy
  import six
  from nnabla.logger import logger
  from .data_source import DataSourceWithFileCache
  from .data_source import DataSourceWithMemoryCache
  from .data_source import SlicedDataSource
  from .data_source_implements import CacheDataSource
  from .data_source_implements import ConcatDataSource
  from .data_source_implements import CsvDataSource
  from .data_source_implements import SimpleDataSource
label_desc: Use image node_id 5 for calling a global function with example usage: data_iterator_concat_datasets(data_source_list, batch_size, shuffle, rng, use_thread, with_memory_cache, with_file_cache, cache_dir, epoch_begin_callbacks, epoch_end_callbacks, stop_exhausted) and returns: data_iterator