


"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


A     :   Tuple			    =			{
    "configuration_whisper": ["WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP", "WhisperConfig", "WhisperOnnxConfig"],
    "feature_extraction_whisper": ["WhisperFeatureExtractor"],
    "processing_whisper": ["WhisperProcessor"],
    "tokenization_whisper": ["WhisperTokenizer"],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A     :   Tuple			    =			["WhisperTokenizerFast"]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A     :   List[Any]			    =			[
	    "WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "WhisperForConditionalGeneration",
	    "WhisperModel",
	    "WhisperPreTrainedModel",
	    "WhisperForAudioClassification",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A     :   Union[str, Any]			    =			[
	    "TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "TFWhisperForConditionalGeneration",
	    "TFWhisperModel",
	    "TFWhisperPreTrainedModel",
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A     :   List[str]			    =			[
	    "FlaxWhisperForConditionalGeneration",
	    "FlaxWhisperModel",
	    "FlaxWhisperPreTrainedModel",
	    "FlaxWhisperForAudioClassification",
	]


if TYPE_CHECKING:
	from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
	from .feature_extraction_whisper import WhisperFeatureExtractor
	from .processing_whisper import WhisperProcessor
	from .tokenization_whisper import WhisperTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_whisper_fast import WhisperTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_whisper import (
		    WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    WhisperForAudioClassification,
		    WhisperForConditionalGeneration,
		    WhisperModel,
		    WhisperPreTrainedModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_whisper import (
		    TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFWhisperForConditionalGeneration,
		    TFWhisperModel,
		    TFWhisperPreTrainedModel,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_whisper import (
		    FlaxWhisperForAudioClassification,
		    FlaxWhisperForConditionalGeneration,
		    FlaxWhisperModel,
		    FlaxWhisperPreTrainedModel,
		)

else:
	import sys

	A     :   List[Any]			    =			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)








"""simple docstring"""


class   _UpperCamelCase  (   lowerCAmelCase__		):
							'''simple docstring'''







							pass
class   _UpperCamelCase  (   lowerCAmelCase__		):
							'''simple docstring'''







							pass
class   _UpperCamelCase  :
							'''simple docstring'''







							def __init__(     self	):
										__lowerCAmelCase				    =			[
										    [],
										    [],
										    [],
										]

							def 			snake_case				(     self    ,   __a    ,   __a	):
										try:
													if len(self.queues[priority]	) >= 1_00:
																raise OverflowError("Maximum queue size is 100"	)
													self.queues[priority].append(__a	)
										except IndexError:
													raise ValueError("Valid priorities are 0, 1, and 2"	)

							def 			snake_case				(     self	):
										for queue in self.queues:
													if queue:
																return queue.pop(0	)
										raise UnderFlowError("All queues are empty"	)



							def __str__(     self	):
										return "\n".join(f"Priority {i}: {q}" for i, q in enumerate(self.queues	)	)
class   _UpperCamelCase  :
							'''simple docstring'''







							def __init__(     self	):
										__lowerCAmelCase				    =			[]

							def 			snake_case				(     self    ,   __a	):
										if len(self.queue	) == 1_00:
													raise OverFlowError("Maximum queue size is 100"	)
										self.queue.append(__a	)

							def 			snake_case				(     self	):
										if not self.queue:
													raise UnderFlowError("The queue is empty"	)
										else:
													__lowerCAmelCase				    =			min(self.queue	)
													self.queue.remove(__a	)
													return data



							def __str__(     self	):
										return str(self.queue	)


def _lowerCamelCase	(		):

			'''simple docstring'''




			__lowerCAmelCase				    =			FixedPriorityQueue()
			fpq.enqueue(0    , 10      )
			fpq.enqueue(1    , 70      )
			fpq.enqueue(0    , 100      )
			fpq.enqueue(2    , 1      )
			fpq.enqueue(2    , 5      )
			fpq.enqueue(1    , 7      )
			fpq.enqueue(2    , 4      )
			fpq.enqueue(1    , 64      )
			fpq.enqueue(0    , 128      )
			print(_UpperCamelCase      )
			print(fpq.dequeue()      )
			print(fpq.dequeue()      )
			print(fpq.dequeue()      )
			print(fpq.dequeue()      )
			print(fpq.dequeue()      )
			print(_UpperCamelCase      )
			print(fpq.dequeue()      )
			print(fpq.dequeue()      )
			print(fpq.dequeue()      )
			print(fpq.dequeue()      )
			print(fpq.dequeue()      )


def _lowerCamelCase	(		):

			'''simple docstring'''




			__lowerCAmelCase				    =			ElementPriorityQueue()
			epq.enqueue(10      )
			epq.enqueue(70      )
			epq.enqueue(100      )
			epq.enqueue(1      )
			epq.enqueue(5      )
			epq.enqueue(7      )
			epq.enqueue(4      )
			epq.enqueue(64      )
			epq.enqueue(128      )
			print(_UpperCamelCase      )
			print(epq.dequeue()      )
			print(epq.dequeue()      )
			print(epq.dequeue()      )
			print(epq.dequeue()      )
			print(epq.dequeue()      )
			print(_UpperCamelCase      )
			print(epq.dequeue()      )
			print(epq.dequeue()      )
			print(epq.dequeue()      )
			print(epq.dequeue()      )
			print(epq.dequeue()      )


if __name__ == "__main__":
	fixed_priority_queue()
	element_priority_queue()




