
from typing import TYPE_CHECKING

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


_SCREAMING_SNAKE_CASE    :      Union[str, Any]          =			{
    '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:
					_SCREAMING_SNAKE_CASE    :      Tuple          =			['WhisperTokenizerFast']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Optional[Any]          =			[
					    'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'WhisperForConditionalGeneration',
					    'WhisperModel',
					    'WhisperPreTrainedModel',
					    'WhisperForAudioClassification',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Optional[int]          =			[
					    'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFWhisperForConditionalGeneration',
					    'TFWhisperModel',
					    'TFWhisperPreTrainedModel',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Optional[Any]          =			[
					    '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

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

import numpy as np

_SCREAMING_SNAKE_CASE    :      Any          =			[
    ['a', 'b', 'c', 'd', 'e'],
    ['f', 'g', 'h', 'i', 'k'],
    ['l', 'm', 'n', 'o', 'p'],
    ['q', 'r', 's', 't', 'u'],
    ['v', 'w', 'x', 'y', 'z'],
]







class  UpperCamelCase__		:







	'''simple docstring'''





	def __init__(			self		):
					A__  :	List[Any]         =							np.array(UpperCamelCase__		)





	def   __snake_case				(			self				,       UpperCamelCase__		):
					A__       ,							A__  :	Any         =							np.where(letter == self.SQUARE		)
					A__  :	int         =							np.concatenate([indexa + 1, indexa + 1]		)
					return indexes





	def   __snake_case				(			self				,       UpperCamelCase__				,       UpperCamelCase__		):
					A__  :	Union[str, Any]         =							self.SQUARE[indexa - 1, indexa - 1]
					return letter





	def   __snake_case				(			self				,       UpperCamelCase__		):
					A__  :	List[str]         =							message.lower()
					A__  :	str         =							message.replace(''' '''				,       ''''''		)
					A__  :	Union[str, Any]         =							message.replace('''j'''				,       '''i'''		)

					A__  :	List[Any]         =							np.empty((2, len(UpperCamelCase__		))		)
					for letter_index in range(len(UpperCamelCase__		)		):
									A__  :	Any         =							self.letter_to_numbers(message[letter_index]		)

									A__  :	Optional[Any]         =							numbers[0]
									A__  :	List[str]         =							numbers[1]

					A__  :	List[str]         =							first_step.reshape(2 * len(UpperCamelCase__		)		)
					A__  :	List[Any]         =							''''''
					for numbers_index in range(len(UpperCamelCase__		)		):
									A__  :	Dict         =							int(second_step[numbers_index * 2]		)
									A__  :	List[str]         =							int(second_step[(numbers_index * 2) + 1]		)
									A__  :	Dict         =							self.numbers_to_letter(UpperCamelCase__				,       UpperCamelCase__		)
									A__  :	Tuple         =							encoded_message + letter

					return encoded_message





	def   __snake_case				(			self				,       UpperCamelCase__		):
					A__  :	str         =							message.lower()
					message.replace(''' '''				,       ''''''		)
					A__  :	List[Any]         =							np.empty(2 * len(UpperCamelCase__		)		)
					for letter_index in range(len(UpperCamelCase__		)		):
									A__  :	List[str]         =							self.letter_to_numbers(message[letter_index]		)
									A__  :	Dict         =							numbers[0]
									A__  :	int         =							numbers[1]

					A__  :	Optional[Any]         =							first_step.reshape((2, len(UpperCamelCase__		))		)
					A__  :	int         =							''''''
					for numbers_index in range(len(UpperCamelCase__		)		):
									A__  :	Tuple         =							int(second_step[0, numbers_index]		)
									A__  :	Dict         =							int(second_step[1, numbers_index]		)
									A__  :	List[str]         =							self.numbers_to_letter(UpperCamelCase__				,       UpperCamelCase__		)
									A__  :	Tuple         =							decoded_message + letter

					return decoded_message