


'''simple docstring'''
from typing import TYPE_CHECKING

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


__snake_case							      =     {
    '''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							      =     ['''WhisperTokenizerFast''']

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

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

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__snake_case							      =     [
		    '''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							      =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)







import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, Features, Value
from .base import TaskTemplate
@dataclass(frozen=lowercase__   )
class     a    ( lowercase__   ):



      """simple docstring"""


      a  : str							       =	field(default='automatic-speech-recognition'							,       metadata={'include_in_asdict_even_if_is_default': True}   )
      a  : ClassVar[Features]							       =	Features({'audio': Audio()}   )
      a  : ClassVar[Features]							       =	Features({'transcription': Value('string'   )}   )
      a  : str							       =	"audio"
      a  : str							       =	"transcription"
      def 	UpperCAmelCase      (      self					:			Optional[Any]		,      __lowercase					:			Optional[int]					)							->      str:
        if self.audio_column not in features:
          raise ValueError(f"""Column {self.audio_column} is not present in features."""					)
        if not isinstance(features[self.audio_column]		,      __lowercase					):
          raise ValueError(f"""Column {self.audio_column} is not an Audio type."""					)
        __UpperCAmelCase							:	int           =  copy.deepcopy(self					)
        __UpperCAmelCase							:	str           =  self.input_schema.copy()
        __UpperCAmelCase							:	List[str]           =  features[self.audio_column]
        __UpperCAmelCase							:	Optional[Any]           =  input_schema
        return task_template




      @property
      def 	UpperCAmelCase      (      self					:			Union[str, Any]					)							->      Dict[str, str]:
        return {self.audio_column: "audio", self.transcription_column: "transcription"}


