
from typing import TYPE_CHECKING

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


_lowerCamelCase					   ={
    """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:
      _lowerCamelCase					   =["""WhisperTokenizerFast"""]

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

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

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _lowerCamelCase					   =[
          """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

      _lowerCamelCase					   =_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=__SCREAMING_SNAKE_CASE)
class 							A__		(	__SCREAMING_SNAKE_CASE):
      _UpperCAmelCase				:    str           =			field(default="""automatic-speech-recognition"""  ,   metadata={"""include_in_asdict_even_if_is_default""": True})
      _UpperCAmelCase				:    ClassVar[Features]           =			Features({"""audio""": Audio()})
      _UpperCAmelCase				:    ClassVar[Features]           =			Features({"""transcription""": Value("""string""")})
      _UpperCAmelCase				:    str           =			"audio"
      _UpperCAmelCase				:    str           =			"transcription"
      def 						UpperCamelCase__							(      self    ,  __magic_name__      ):
       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]    ,  __magic_name__      ):
        raise ValueError(F'''Column {self.audio_column} is not an Audio type.'''      )
       lowerCamelCase		:	Optional[Any]							=      copy.deepcopy(self      )
       lowerCamelCase		:	List[Any]							=      self.input_schema.copy()
       lowerCamelCase		:	Tuple							=      features[self.audio_column]
       lowerCamelCase		:	int							=      input_schema
       return task_template






      @property
      def 						UpperCamelCase__							(      self      ):
       return {self.audio_column: "audio", self.transcription_column: "transcription"}




