




'''simple docstring'''


import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...utils import CONFIG_NAME, FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


UpperCAmelCase_					=   logging.get_logger(__name__)

UpperCAmelCase_					=   OrderedDict(
    [
        ("audio-spectrogram-transformer", "ASTFeatureExtractor"),
        ("beit", "BeitFeatureExtractor"),
        ("chinese_clip", "ChineseCLIPFeatureExtractor"),
        ("clap", "ClapFeatureExtractor"),
        ("clip", "CLIPFeatureExtractor"),
        ("clipseg", "ViTFeatureExtractor"),
        ("conditional_detr", "ConditionalDetrFeatureExtractor"),
        ("convnext", "ConvNextFeatureExtractor"),
        ("cvt", "ConvNextFeatureExtractor"),
        ("data2vec-audio", "Wav2Vec2FeatureExtractor"),
        ("data2vec-vision", "BeitFeatureExtractor"),
        ("deformable_detr", "DeformableDetrFeatureExtractor"),
        ("deit", "DeiTFeatureExtractor"),
        ("detr", "DetrFeatureExtractor"),
        ("dinat", "ViTFeatureExtractor"),
        ("donut-swin", "DonutFeatureExtractor"),
        ("dpt", "DPTFeatureExtractor"),
        ("encodec", "EncodecFeatureExtractor"),
        ("flava", "FlavaFeatureExtractor"),
        ("glpn", "GLPNFeatureExtractor"),
        ("groupvit", "CLIPFeatureExtractor"),
        ("hubert", "Wav2Vec2FeatureExtractor"),
        ("imagegpt", "ImageGPTFeatureExtractor"),
        ("layoutlmv2", "LayoutLMv2FeatureExtractor"),
        ("layoutlmv3", "LayoutLMv3FeatureExtractor"),
        ("levit", "LevitFeatureExtractor"),
        ("maskformer", "MaskFormerFeatureExtractor"),
        ("mctct", "MCTCTFeatureExtractor"),
        ("mobilenet_v1", "MobileNetV1FeatureExtractor"),
        ("mobilenet_v2", "MobileNetV2FeatureExtractor"),
        ("mobilevit", "MobileViTFeatureExtractor"),
        ("nat", "ViTFeatureExtractor"),
        ("owlvit", "OwlViTFeatureExtractor"),
        ("perceiver", "PerceiverFeatureExtractor"),
        ("poolformer", "PoolFormerFeatureExtractor"),
        ("regnet", "ConvNextFeatureExtractor"),
        ("resnet", "ConvNextFeatureExtractor"),
        ("segformer", "SegformerFeatureExtractor"),
        ("sew", "Wav2Vec2FeatureExtractor"),
        ("sew-d", "Wav2Vec2FeatureExtractor"),
        ("speech_to_text", "Speech2TextFeatureExtractor"),
        ("speecht5", "SpeechT5FeatureExtractor"),
        ("swiftformer", "ViTFeatureExtractor"),
        ("swin", "ViTFeatureExtractor"),
        ("swinv2", "ViTFeatureExtractor"),
        ("table-transformer", "DetrFeatureExtractor"),
        ("timesformer", "VideoMAEFeatureExtractor"),
        ("tvlt", "TvltFeatureExtractor"),
        ("unispeech", "Wav2Vec2FeatureExtractor"),
        ("unispeech-sat", "Wav2Vec2FeatureExtractor"),
        ("van", "ConvNextFeatureExtractor"),
        ("videomae", "VideoMAEFeatureExtractor"),
        ("vilt", "ViltFeatureExtractor"),
        ("vit", "ViTFeatureExtractor"),
        ("vit_mae", "ViTFeatureExtractor"),
        ("vit_msn", "ViTFeatureExtractor"),
        ("wav2vec2", "Wav2Vec2FeatureExtractor"),
        ("wav2vec2-conformer", "Wav2Vec2FeatureExtractor"),
        ("wavlm", "Wav2Vec2FeatureExtractor"),
        ("whisper", "WhisperFeatureExtractor"),
        ("xclip", "CLIPFeatureExtractor"),
        ("yolos", "YolosFeatureExtractor"),
    ]
)

UpperCAmelCase_					=   _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)


def     SCREAMING_SNAKE_CASE							(   a_						:				str      ):
  for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
    if class_name in extractors:
      __a								=       model_type_to_module_name(a_      )

      __a								=       importlib.import_module(f".{module_name}"					,       'transformers.models'      )
      try:
        return getattr(a_					,       a_      )
      except AttributeError:
        continue

  for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
    if getattr(a_					,       '__name__'					,       a_      ) == class_name:
      return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
  __a								=       importlib.import_module('transformers'      )
  if hasattr(a_					,       a_      ):
    return getattr(a_					,       a_      )

  return None


def     SCREAMING_SNAKE_CASE							(   a_						:				Union[str, os.PathLike]					,       a_						:				Optional[Union[str, os.PathLike]] = None					,       a_						:				bool = False					,       a_						:				bool = False					,       a_						:				Optional[Dict[str, str]] = None					,       a_						:				Optional[Union[bool, str]] = None					,       a_						:				Optional[str] = None					,       a_						:				bool = False					,       **a_						:				int					,       ):
  __a								=       get_file_from_repo(
      a_					,       a_					,       cache_dir=a_					,       force_download=a_					,       resume_download=a_					,       proxies=a_					,       use_auth_token=a_					,       revision=a_					,       local_files_only=a_					,       )
  if resolved_config_file is None:
    logger.info(
        'Could not locate the feature extractor configuration file, will try to use the model config instead.'      )
    return {}

  with open(a_					,       encoding='utf-8'      ) as reader:
    return json.load(a_      )





class  __lowercase    :







   def __init__(						self   )					->     Optional[int]:
     raise EnvironmentError(
         'AutoFeatureExtractor is designed to be instantiated '
         'using the `AutoFeatureExtractor.from_pretrained(pretrained_model_name_or_path)` method.'   )







   @classmethod
   @replace_list_option_in_docstrings(UpperCamelCase   )
   def 		UpperCamelCase__      (						cls   ,				UpperCamelCase   ,				**UpperCamelCase   )					->     Optional[Any]:
     __a								=       kwargs.pop('config'   ,				UpperCamelCase   )
     __a								=       kwargs.pop('trust_remote_code'   ,				UpperCamelCase   )
     __a								=       True

     __a						,							__a								=       FeatureExtractionMixin.get_feature_extractor_dict(UpperCamelCase   ,				**UpperCamelCase   )
     __a								=       config_dict.get('feature_extractor_type'   ,				UpperCamelCase   )
     __a								=       None
     if "AutoFeatureExtractor" in config_dict.get('auto_map'   ,				{}   ):
       __a								=       config_dict['auto_map']['AutoFeatureExtractor']

     # If we don't find the feature extractor class in the feature extractor config, let's try the model config.
     if feature_extractor_class is None and feature_extractor_auto_map is None:
       if not isinstance(UpperCamelCase   ,				UpperCamelCase   ):
         __a								=       AutoConfig.from_pretrained(UpperCamelCase   ,				**UpperCamelCase   )
       # It could be in `config.feature_extractor_type``
       __a								=       getattr(UpperCamelCase   ,				'feature_extractor_type'   ,				UpperCamelCase   )
       if hasattr(UpperCamelCase   ,				'auto_map'   ) and "AutoFeatureExtractor" in config.auto_map:
         __a								=       config.auto_map['AutoFeatureExtractor']

     if feature_extractor_class is not None:
       __a								=       feature_extractor_class_from_name(UpperCamelCase   )

     __a								=       feature_extractor_auto_map is not None
     __a								=       feature_extractor_class is not None or type(UpperCamelCase   ) in FEATURE_EXTRACTOR_MAPPING
     __a								=       resolve_trust_remote_code(
         UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )

     if has_remote_code and trust_remote_code:
       __a								=       get_class_from_dynamic_module(
           UpperCamelCase   ,				UpperCamelCase   ,				**UpperCamelCase   )
       __a								=       kwargs.pop('code_revision'   ,				UpperCamelCase   )
       if os.path.isdir(UpperCamelCase   ):
         feature_extractor_class.register_for_auto_class()
       return feature_extractor_class.from_dict(UpperCamelCase   ,				**UpperCamelCase   )
     elif feature_extractor_class is not None:
       return feature_extractor_class.from_dict(UpperCamelCase   ,				**UpperCamelCase   )
     # Last try: we use the FEATURE_EXTRACTOR_MAPPING.
     elif type(UpperCamelCase   ) in FEATURE_EXTRACTOR_MAPPING:
       __a								=       FEATURE_EXTRACTOR_MAPPING[type(UpperCamelCase   )]
       return feature_extractor_class.from_dict(UpperCamelCase   ,				**UpperCamelCase   )

     raise ValueError(
         f"Unrecognized feature extractor in {pretrained_model_name_or_path}. Should have a "
         f"`feature_extractor_type` key in its {FEATURE_EXTRACTOR_NAME} of {CONFIG_NAME}, or one of the following "
         f"`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in FEATURE_EXTRACTOR_MAPPING_NAMES.keys()   )}"   )







   @staticmethod
   def 		UpperCamelCase__      (						UpperCamelCase   ,				UpperCamelCase   )					->     Tuple:
     FEATURE_EXTRACTOR_MAPPING.register(UpperCamelCase   ,				UpperCamelCase   )









'''simple docstring'''


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

from ..features import Audio, ClassLabel, Features
from .base import TaskTemplate





@dataclass(frozen=__magic_name__			)
class  __lowercase    (	__magic_name__			):
   _a    						=   field(default="""audio-classification"""							,				metadata={"""include_in_asdict_even_if_is_default""": True}			)
   _a    						=   Features({"""audio""": Audio()}			)
   _a    						=   Features({"""labels""": ClassLabel}			)
   _a    						=   "audio"
   _a    						=   "labels"







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Dict:
     if self.label_column not in features:
       raise ValueError(f"Column {self.label_column} is not present in features."   )
     if not isinstance(features[self.label_column]   ,				UpperCamelCase   ):
       raise ValueError(f"Column {self.label_column} is not a ClassLabel."   )
     __a								=       copy.deepcopy(self   )
     __a								=       self.label_schema.copy()
     __a								=       features[self.label_column]
     __a								=       label_schema
     return task_template







   @property
   def 		UpperCamelCase__      (						self   )					->     Dict[str, str]:
     return {
         self.audio_column: "audio",
         self.label_column: "labels",
     }



