



'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase:					List[Any]						       =						{
    """configuration_timesformer""": ["""TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """TimesformerConfig"""],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase:					Tuple						       =						[
         """TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """TimesformerModel""",
         """TimesformerForVideoClassification""",
         """TimesformerPreTrainedModel""",
     ]

if TYPE_CHECKING:
     from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_timesformer import (
              TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TimesformerForVideoClassification,
              TimesformerModel,
              TimesformerPreTrainedModel,
          )

else:
     import sys

     lowerCAmelCase:					Optional[int]						       =						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






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

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





class  A__    (							Generic[_T]	):




   """simple docstring"""



   def __init__(					self					,  lowercase = None)			->						None:







          '''simple docstring'''

          a__						:	list[_T] =				list(iterable or [])
          a__						:	list[_T] =				[]

   def __len__(					self)			->						int:







          '''simple docstring'''

          return len(self._stacka) + len(self._stacka)

   def __repr__(					self)			->						str:







          '''simple docstring'''

          return F'Queue({tuple(self._stacka[::-1] + self._stacka)})'

   def 							__lowercase		(					self					,  lowercase)			->						None:







          '''simple docstring'''

          self._stacka.append(lowercase)

   def 							__lowercase		(					self)			->						_T:







          '''simple docstring'''

          a__						:	List[str] =				self._stacka.pop
          a__						:	Optional[int] =				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()


