'''simple docstring'''

from collections.abc import Iterable
from typing import Generic, TypeVar

__a: Any          =   TypeVar("""_T""")



class 			UpperCAmelCase  (						Generic[_T]					):





       '''simple docstring'''



       def __init__(						self	,   __lowerCAmelCase = None )  ->  None:
        lowercase__				:    list[_T]  =					list(iterable or [] )
        lowercase__				:    list[_T]  =					[]

       def __len__(						self )  ->  int:
        return len(self._stacka ) + len(self._stacka )

       def __repr__(						self )  ->  str:
        return F"""Queue({tuple(self._stacka[::-1] + self._stacka )})"""

       def _lowerCAmelCase(						self	,   __lowerCAmelCase )  ->  None:
        self._stacka.append(__a )


       def _lowerCAmelCase(						self )  ->  _T:
        lowercase__				:    Any  =					self._stacka.pop
        lowercase__				:    Optional[Any]  =					self._stacka.append

        if not self._stacka:
         while self._stacka:
          stacka_append(stacka_pop() )

        if not self._stacka:
         raise IndexError('''Queue is empty''' )
        return self._stacka.pop()


if __name__ == "__main__":
  from doctest import testmod

  testmod()









lowerCamelCase       :       Dict        =				'''0.21.0'''

from .accelerator import Accelerator
from .big_modeling import (
    cpu_offload,
    cpu_offload_with_hook,
    disk_offload,
    dispatch_model,
    init_empty_weights,
    init_on_device,
    load_checkpoint_and_dispatch,
)
from .data_loader import skip_first_batches
from .launchers import debug_launcher, notebook_launcher
from .state import PartialState
from .utils import (
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    FullyShardedDataParallelPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    find_executable_batch_size,
    infer_auto_device_map,
    is_rich_available,
    load_checkpoint_in_model,
    synchronize_rng_states,
)


if is_rich_available():
	from .utils import rich