class_docstr: RoundRobinIterator cycles over the dataloader one by one.
  Iterating order can be defined via RobinRobin strategy.
  
  This supports two stopping mechanisms:
  1. ALL_DATASETS_EXHAUSTED: Iterates till the largest dataset is exhausted,
  while skipping those that are done
  2. SMALLEST_DATASET_EXHAUSTED: Stops iteration once the smallest dataset
  has been exhausted
  
  Returns batches of the format: {dataloader_name: batch_from_dataloader}
  
  Args:
      individual_dataloaders (Mapping[str, Union[DataLoader, Iterable]]): A mapping of DataLoaders or Iterables with dataloader name as key
      and dataloader/iterable object as value.
      iteration_strategy (RoundRobin): A RoundRobin dataclass indicating how the dataloaders are iterated over.
  
  Examples:
      >>> loaders = {'a': torch.utils.data.DataLoader(range(4), batch_size=4),
          'b': torch.utils.data.DataLoader(range(15), batch_size=5)}
      >>> round_robin_strategy = RoundRobin(
              stopping_mechanism=StoppingMechanism.ALL_DATASETS_EXHAUSTED
          )
      >>> combined_iterator = RoundRobinIterator(loaders, round_robin_strategy)
      >>> for item in combined_iterator:
              print(item)
      {'a': tensor([0, 1, 2, 3])}
      {'b': tensor([0, 1, 2, 3, 4])}
      {'b': tensor([5, 6, 7, 8, 9])}
      {'b': tensor([10, 11, 12, 13, 14])}
code: def __init__(
      self,
      # pyre-fixme[24]: Generic type `Iterable` expects 1 type parameter
      individual_dataloaders: Mapping[str, Union[DataLoader, Iterable]],
      iteration_strategy: RoundRobin,
  ) -> None:
      super().__init__(individual_dataloaders, iteration_strategy)
      self.iteration_strategy = iteration_strategy
  
      if (
          self.iteration_strategy.stopping_mechanism
          == StoppingMechanism.WRAP_AROUND_UNTIL_KILLED
      ):
          raise NotImplementedError(
              "WRAP_AROUND_UNTIL_KILLED is not implemented for RoundRobin"
          )
      self.individual_iterators: Mapping[str, Iterator[DataLoader]] = {
          name: iter(dl) for name, dl in individual_dataloaders.items()
      }
      round_robin_order = iteration_strategy.iteration_order or list(
          self.individual_iterators.keys()
      )
      self.dataloader_cycle: Iterator[str] = cycle(round_robin_order)
      self.cur_dataloader: str = round_robin_order[0]
      self.finished_dataloaders: List[str] = []
  
imports: from __future__ import annotations
  import random
  from abc import abstractmethod
  from dataclasses import dataclass
  from enum import Enum
  from itertools import cycle
  from typing import Any, Dict, Iterable, Iterator, List, Mapping, MutableMapping, Optional, Type, TYPE_CHECKING, Union
  import torch
  import torch.distributed
label_desc: Use image node_id 1 to create a new RoundRobinIterator object from inherited base classes: MultiIterator with example: obj = RoundRobinIterator(individual_dataloaders, iteration_strategy)