code: def _traverse_supported_dataset(
      dataset: Y,
      values_selector: Callable[
          [Y, Optional[List[int]]], Optional[Sequence[T]]
      ],
      indices: Optional[List[int]] = None,
  ) -> Sequence[T]:
      """
      Traverse the given dataset by gathering required info.
  
      The given dataset is traversed by covering all sub-datasets
      contained PyTorch :class:`Subset` and :class`ConcatDataset`.
      Beware that instances of :class:`AvalancheDataset` will not
      be traversed as those objects already have the proper data
      attribute fields populated with data from leaf datasets.
  
      For each dataset, the `values_selector` will be called to gather
      the required information. The values returned by the given selector
      are then concatenated to create a final list of values.
  
      :param dataset: The dataset to traverse.
      :param values_selector: A function that, given the dataset
          and the indices to consider (which may be None if the entire
          dataset must be considered), returns a list of selected values.
      :returns: The list of selected values.
      """
      initial_error = None
      try:
          result = values_selector(dataset, indices)
          if result is not None:
              return result
      except BaseException as e:
          initial_error = e
  
      if isinstance(dataset, Subset):
          if indices is None:
              indices = [
                  dataset.indices[x] for x in range(len(dataset))
              ]
          else:
              indices = [dataset.indices[x] for x in indices]
  
          return list(
              _traverse_supported_dataset(
                  dataset.dataset, values_selector, indices
              )
          )
  
      if isinstance(dataset, ConcatDataset):
          result = []
          if indices is None:
              for c_dataset in dataset.datasets:
                  result_data = _traverse_supported_dataset(
                      c_dataset, values_selector
                  )
                  if isinstance(result_data, Tensor):
                      result += result_data.tolist()
                  else:
                      result += list(result_data)
              return result
  
          datasets_to_indexes = defaultdict(list)
          indexes_to_dataset = []
          datasets_len = []
          recursion_result = []
  
          all_size = 0
          for c_dataset in dataset.datasets:
              len_dataset = len(c_dataset)
              datasets_len.append(len_dataset)
              all_size += len_dataset
  
          for subset_idx in indices:
              dataset_idx, pattern_idx = find_list_from_index(
                  subset_idx, datasets_len, all_size
              )
              datasets_to_indexes[dataset_idx].append(pattern_idx)
              indexes_to_dataset.append(dataset_idx)
  
          for dataset_idx, c_dataset in enumerate(dataset.datasets):
              recursion_result.append(
                  deque(
                      _traverse_supported_dataset(
                          c_dataset,
                          values_selector,
                          datasets_to_indexes[dataset_idx],
                      )
                  )
              )
  
          result = []
          for idx in range(len(indices)):
              dataset_idx = indexes_to_dataset[idx]
              result.append(recursion_result[dataset_idx].popleft())
  
          return result
  
      if initial_error is not None:
          raise initial_error
  
      raise ValueError(
          "Error: can't find the needed data in the given dataset"
      )
  
imports: from collections import OrderedDict, defaultdict, deque
  from typing import TYPE_CHECKING, Any, Callable, Generic, Iterator, List, Iterable, Mapping, Optional, Sequence, TypeVar, Union, Dict, SupportsInt
  import warnings
  import torch
  from torch import Tensor
  from torch.utils.data import Subset, ConcatDataset
  from .data import AvalancheDataset
  from .data_attribute import DataAttribute
  from .dataset_definitions import ISupportedClassificationDataset
  from .dataset_utils import SubSequence, find_list_from_index
  from .flat_data import ConstantSequence
  from .transform_groups import TransformGroupDef, TransformGroups, XTransform, YTransform
label_desc: Use image node_id 10 for calling a global function with example usage: _traverse_supported_dataset(dataset, values_selector, indices) and returns: list, result, result, result