


from typing import TYPE_CHECKING

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


_snake_case	:						str         =							{
    "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:
			_snake_case	:						Optional[Any]         =							["WhisperTokenizerFast"]

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

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_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:
			_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

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



"""simple docstring"""


from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import pyarrow as pa


if TYPE_CHECKING:
						from .features import FeatureType




@dataclass
class  __lowerCamelCase  :
				a__:      List[str]
				a__:      Optional[str]          =    None
				# Automatically constructed
				a__:      ClassVar[str]          =    "dict"
				a__:      ClassVar[Any]          =    None
				a__:      str          =    field(default='Translation'						,	init=lowerCAmelCase						,	repr=lowerCAmelCase			)




				def __call__(				self   ):
							return pa.struct({lang: pa.string() for lang in sorted(self.languages   )}   )





				def        UpperCAmelCase__						(				self   ):
							from .features import Value

							return {k: Value('''string'''   ) for k in sorted(self.languages   )}




@dataclass
class  __lowerCamelCase  :
				a__:      Optional[List]          =    None
				a__:      Optional[int]          =    None
				a__:      Optional[str]          =    None
				# Automatically constructed
				a__:      ClassVar[str]          =    "dict"
				a__:      ClassVar[Any]          =    None
				a__:      str          =    field(default='TranslationVariableLanguages'						,	init=lowerCAmelCase						,	repr=lowerCAmelCase			)




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  sorted(set(self.languages   )   ) if self.languages else None
							lowerCamelCase_					=  len(self.languages   ) if self.languages else None




				def __call__(				self   ):
							return pa.struct({'''language''': pa.list_(pa.string()   ), '''translation''': pa.list_(pa.string()   )}   )




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							lowerCamelCase_					=  set(self.languages   )
							if self.languages and set(UpperCAmelCase   ) - lang_set:
										raise ValueError(
										    f"Some languages in example ({', '.join(sorted(set(UpperCAmelCase   ) - lang_set   )   )}) are not in valid set ({', '.join(UpperCAmelCase   )})."   )

							# Convert dictionary into tuples, splitting out cases where there are
							# multiple translations for a single language.
							lowerCamelCase_					=  []
							for lang, text in translation_dict.items():
										if isinstance(UpperCAmelCase							,						UpperCAmelCase   ):
													translation_tuples.append((lang, text)   )
										else:
													translation_tuples.extend([(lang, el) for el in text]   )

        # Ensure translations are in ascending order by language code.
							lowerCamelCase_		, lowerCamelCase_					=  zip(*sorted(UpperCAmelCase   )   )

							return {"language": languages, "translation": translations}





				def        UpperCAmelCase__						(				self   ):
							from .features import Sequence, Value

							return {
							    "language": Sequence(Value('''string'''   )   ),
							    "translation": Sequence(Value('''string'''   )   ),
							}



