




class 		__UpperCAmelCase:





     """simple docstring"""



     def __init__(      self :       Tuple    )			->			str:






         """simple docstring"""
         a__      =       []
         a__      =       0
         a__      =       0

     def __str__(      self :       str    )			->			List[str]:






         """simple docstring"""
         a__      =       """<""" + str(self.entries    )[1:-1] + """>"""
         return printed

     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[Any]						,				A :       str    )			->			List[str]:






         """simple docstring"""
         self.entries.append(A    )
         a__      =       self.length + 1

     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[int]    )			->			Union[str, Any]:






         """simple docstring"""
         a__      =       self.length - 1
         a__      =       self.entries[self.front]
         # self.front-=1
         # self.entries = self.entries[self.front:]
         a__      =       self.entries[1:]
         return dequeued

     def 				__SCREAMING_SNAKE_CASE		(      self :       List[Any]						,				A :       str    )			->			str:






         """simple docstring"""
         for _ in range(A    ):
             self.put(self.get()    )

     def 				__SCREAMING_SNAKE_CASE		(      self :       Union[str, Any]    )			->			Dict:






         """simple docstring"""
         return self.entries[0]

     def 				__SCREAMING_SNAKE_CASE		(      self :       str    )			->			Union[str, Any]:






         """simple docstring"""
         return self.length












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


SCREAMING_SNAKE_CASE_						:					str			   =       {
    '''configuration_wav2vec2_conformer''': [
        '''WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Wav2Vec2ConformerConfig''',
    ],
}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_						:					Optional[int]			   =       [
     '''WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''Wav2Vec2ConformerForAudioFrameClassification''',
     '''Wav2Vec2ConformerForCTC''',
     '''Wav2Vec2ConformerForPreTraining''',
     '''Wav2Vec2ConformerForSequenceClassification''',
     '''Wav2Vec2ConformerForXVector''',
     '''Wav2Vec2ConformerModel''',
     '''Wav2Vec2ConformerPreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_wavaveca_conformer import (
     WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
     WavaVecaConformerConfig,
 )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_wavaveca_conformer import (
      WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      WavaVecaConformerForAudioFrameClassification,
      WavaVecaConformerForCTC,
      WavaVecaConformerForPreTraining,
      WavaVecaConformerForSequenceClassification,
      WavaVecaConformerForXVector,
      WavaVecaConformerModel,
      WavaVecaConformerPreTrainedModel,
  )

else:
 import sys

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






