





"""simple docstring"""
import importlib
import inspect
import json
import os
from collections import OrderedDict

# 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 ...image_processing_utils import ImageProcessingMixin
from ...tokenization_utils import TOKENIZER_CONFIG_FILE
from ...utils import 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,
)
from .feature_extraction_auto import AutoFeatureExtractor
from .image_processing_auto import AutoImageProcessor
from .tokenization_auto import AutoTokenizer


__UpperCamelCase			:		Tuple		    =   logging.get_logger(__name__)

__UpperCamelCase			:		Any		    =   OrderedDict(
    [
        ('''align''', '''AlignProcessor'''),
        ('''altclip''', '''AltCLIPProcessor'''),
        ('''bark''', '''BarkProcessor'''),
        ('''blip''', '''BlipProcessor'''),
        ('''blip-2''', '''Blip2Processor'''),
        ('''bridgetower''', '''BridgeTowerProcessor'''),
        ('''chinese_clip''', '''ChineseCLIPProcessor'''),
        ('''clap''', '''ClapProcessor'''),
        ('''clip''', '''CLIPProcessor'''),
        ('''clipseg''', '''CLIPSegProcessor'''),
        ('''flava''', '''FlavaProcessor'''),
        ('''git''', '''GitProcessor'''),
        ('''groupvit''', '''CLIPProcessor'''),
        ('''hubert''', '''Wav2Vec2Processor'''),
        ('''instructblip''', '''InstructBlipProcessor'''),
        ('''layoutlmv2''', '''LayoutLMv2Processor'''),
        ('''layoutlmv3''', '''LayoutLMv3Processor'''),
        ('''markuplm''', '''MarkupLMProcessor'''),
        ('''mctct''', '''MCTCTProcessor'''),
        ('''mgp-str''', '''MgpstrProcessor'''),
        ('''oneformer''', '''OneFormerProcessor'''),
        ('''owlvit''', '''OwlViTProcessor'''),
        ('''pix2struct''', '''Pix2StructProcessor'''),
        ('''sam''', '''SamProcessor'''),
        ('''sew''', '''Wav2Vec2Processor'''),
        ('''sew-d''', '''Wav2Vec2Processor'''),
        ('''speech_to_text''', '''Speech2TextProcessor'''),
        ('''speech_to_text_2''', '''Speech2Text2Processor'''),
        ('''speecht5''', '''SpeechT5Processor'''),
        ('''trocr''', '''TrOCRProcessor'''),
        ('''tvlt''', '''TvltProcessor'''),
        ('''unispeech''', '''Wav2Vec2Processor'''),
        ('''unispeech-sat''', '''Wav2Vec2Processor'''),
        ('''vilt''', '''ViltProcessor'''),
        ('''vision-text-dual-encoder''', '''VisionTextDualEncoderProcessor'''),
        ('''wav2vec2''', '''Wav2Vec2Processor'''),
        ('''wav2vec2-conformer''', '''Wav2Vec2Processor'''),
        ('''wavlm''', '''Wav2Vec2Processor'''),
        ('''whisper''', '''WhisperProcessor'''),
        ('''xclip''', '''XCLIPProcessor'''),
    ]
)

__UpperCamelCase			:		Optional[int]		    =   _LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)

def 						_SCREAMING_SNAKE_CASE       (_UpperCAmelCase :  str       ):
 for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
  if class_name in processors:
   lowerCAmelCase  							=      model_type_to_module_name(_UpperCAmelCase       )

   lowerCAmelCase  							=      importlib.import_module(F'.{module_name}'   ,			'transformers.models'       )
   try:
    return getattr(_UpperCAmelCase   ,			_UpperCAmelCase       )
   except AttributeError:
    continue

 for processor in PROCESSOR_MAPPING._extra_content.values():
  if getattr(_UpperCAmelCase   ,			'__name__'   ,			_UpperCAmelCase       ) == class_name:
   return processor

    # 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.
 lowerCAmelCase  							=      importlib.import_module('transformers'       )
 if hasattr(_UpperCAmelCase   ,			_UpperCAmelCase       ):
  return getattr(_UpperCAmelCase   ,			_UpperCAmelCase       )

 return None







class 	a				:



 def __init__(			self			):







  """simple docstring"""






  raise EnvironmentError(
      'AutoProcessor is designed to be instantiated '
      'using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method.'			)



 @classmethod
 @replace_list_option_in_docstrings(_snake_case			)
 def 					UpperCamelCase__   (			cls							,    _snake_case							,    **_snake_case			):







  """simple docstring"""






  lowerCAmelCase  							=      kwargs.pop('config'							,    _snake_case			)
  lowerCAmelCase  							=      kwargs.pop('trust_remote_code'							,    _snake_case			)
  lowerCAmelCase  							=      True

  lowerCAmelCase  							=      None
  lowerCAmelCase  							=      None

  # First, let's see if we have a preprocessor config.
  # Filter the kwargs for `get_file_from_repo`.
  lowerCAmelCase  							=      {
      key: kwargs[key] for key in inspect.signature(_snake_case			).parameters.keys() if key in kwargs
  }
  # Let's start by checking whether the processor class is saved in an image processor
  lowerCAmelCase  							=      get_file_from_repo(
      _snake_case							,    _snake_case							,    **_snake_case			)
  if preprocessor_config_file is not None:
   lowerCAmelCase							,lowerCAmelCase  							=      ImageProcessingMixin.get_image_processor_dict(_snake_case							,    **_snake_case			)
   lowerCAmelCase  							=      config_dict.get('processor_class'							,    _snake_case			)
   if "AutoProcessor" in config_dict.get('auto_map'							,    {}			):
    lowerCAmelCase  							=      config_dict['auto_map']['AutoProcessor']

        # If not found, let's check whether the processor class is saved in a feature extractor config
  if preprocessor_config_file is not None and processor_class is None:
   lowerCAmelCase							,lowerCAmelCase  							=      FeatureExtractionMixin.get_feature_extractor_dict(_snake_case							,    **_snake_case			)
   lowerCAmelCase  							=      config_dict.get('processor_class'							,    _snake_case			)
   if "AutoProcessor" in config_dict.get('auto_map'							,    {}			):
    lowerCAmelCase  							=      config_dict['auto_map']['AutoProcessor']

  if processor_class is None:
   # Next, let's check whether the processor class is saved in a tokenizer
   lowerCAmelCase  							=      get_file_from_repo(
       _snake_case							,    _snake_case							,    **_snake_case			)
   if tokenizer_config_file is not None:
    with open(_snake_case							,    encoding='utf-8'			) as reader:
     lowerCAmelCase  							=      json.load(_snake_case			)

    lowerCAmelCase  							=      config_dict.get('processor_class'							,    _snake_case			)
    if "AutoProcessor" in config_dict.get('auto_map'							,    {}			):
     lowerCAmelCase  							=      config_dict['auto_map']['AutoProcessor']

  if processor_class is None:
   # Otherwise, load config, if it can be loaded.
   if not isinstance(_snake_case							,    _snake_case			):
    lowerCAmelCase  							=      AutoConfig.from_pretrained(
        _snake_case							,    trust_remote_code=_snake_case							,    **_snake_case			)

   # And check if the config contains the processor class.
   lowerCAmelCase  							=      getattr(_snake_case							,    'processor_class'							,    _snake_case			)
   if hasattr(_snake_case							,    'auto_map'			) and "AutoProcessor" in config.auto_map:
    lowerCAmelCase  							=      config.auto_map['AutoProcessor']

  if processor_class is not None:
   lowerCAmelCase  							=      processor_class_from_name(_snake_case			)

  lowerCAmelCase  							=      processor_auto_map is not None
  lowerCAmelCase  							=      processor_class is not None or type(_snake_case			) in PROCESSOR_MAPPING
  lowerCAmelCase  							=      resolve_trust_remote_code(
      _snake_case							,    _snake_case							,    _snake_case							,    _snake_case			)

  if has_remote_code and trust_remote_code:
   lowerCAmelCase  							=      get_class_from_dynamic_module(
       _snake_case							,    _snake_case							,    **_snake_case			)
   lowerCAmelCase  							=      kwargs.pop('code_revision'							,    _snake_case			)
   if os.path.isdir(_snake_case			):
    processor_class.register_for_auto_class()
   return processor_class.from_pretrained(
       _snake_case							,    trust_remote_code=_snake_case							,    **_snake_case			)
  elif processor_class is not None:
   return processor_class.from_pretrained(
       _snake_case							,    trust_remote_code=_snake_case							,    **_snake_case			)
  # Last try: we use the PROCESSOR_MAPPING.
  elif type(_snake_case			) in PROCESSOR_MAPPING:
   return PROCESSOR_MAPPING[type(_snake_case			)].from_pretrained(_snake_case							,    **_snake_case			)

  # At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
  # tokenizer.
  try:
   return AutoTokenizer.from_pretrained(
       _snake_case							,    trust_remote_code=_snake_case							,    **_snake_case			)
  except Exception:
   try:
    return AutoImageProcessor.from_pretrained(
        _snake_case							,    trust_remote_code=_snake_case							,    **_snake_case			)
   except Exception:
    pass

   try:
    return AutoFeatureExtractor.from_pretrained(
        _snake_case							,    trust_remote_code=_snake_case							,    **_snake_case			)
   except Exception:
    pass

  raise ValueError(
      F'Unrecognized processing class in {pretrained_model_name_or_path}. Can\'t instantiate a processor, a '
      'tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains'
      'the files of at least one of those processing classes.'			)



 @staticmethod
 def 					UpperCamelCase__   (			_snake_case							,    _snake_case			):







  """simple docstring"""






  PROCESSOR_MAPPING.register(_snake_case							,    _snake_case			)












"""simple docstring"""
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin







class 	a				(					a__   ):
 snake_case__    	=    '''AutoFeatureExtractor'''
 snake_case__    	=    '''Speech2Text2Tokenizer'''



 def __init__(			self							,    _snake_case							,    _snake_case			):







  """simple docstring"""






  super().__init__(_snake_case							,    _snake_case			)
  lowerCAmelCase  							=      self.feature_extractor
  lowerCAmelCase  							=      False



 def __call__(			self							,    *_snake_case							,    **_snake_case			):







  """simple docstring"""






  if self._in_target_context_manager:
   return self.current_processor(*_snake_case							,    **_snake_case			)

  if "raw_speech" in kwargs:
   warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'			)
   lowerCAmelCase  							=      kwargs.pop('raw_speech'			)
  else:
   lowerCAmelCase  							=      kwargs.pop('audio'							,    _snake_case			)
  lowerCAmelCase  							=      kwargs.pop('sampling_rate'							,    _snake_case			)
  lowerCAmelCase  							=      kwargs.pop('text'							,    _snake_case			)
  if len(_snake_case			) > 0:
   lowerCAmelCase  							=      args[0]
   lowerCAmelCase  							=      args[1:]

  if audio is None and text is None:
   raise ValueError('You need to specify either an `audio` or `text` input to process.'			)

  if audio is not None:
   lowerCAmelCase  							=      self.feature_extractor(_snake_case							,    *_snake_case							,    sampling_rate=_snake_case							,    **_snake_case			)
  if text is not None:
   lowerCAmelCase  							=      self.tokenizer(_snake_case							,    **_snake_case			)

  if text is None:
   return inputs
  elif audio is None:
   return encodings
  else:
   lowerCAmelCase  							=      encodings['input_ids']
   return inputs



 def 					UpperCamelCase__   (			self							,    *_snake_case							,    **_snake_case			):







  """simple docstring"""






  return self.tokenizer.batch_decode(*_snake_case							,    **_snake_case			)



 def 					UpperCamelCase__   (			self							,    *_snake_case							,    **_snake_case			):







  """simple docstring"""






  return self.tokenizer.decode(*_snake_case							,    **_snake_case			)



 @contextmanager
 def 					UpperCamelCase__   (			self			):







  """simple docstring"""






  warnings.warn(
      '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
      'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
      'your audio inputs, or in a separate call.'			)
  lowerCAmelCase  							=      True
  lowerCAmelCase  							=      self.tokenizer
  yield
  lowerCAmelCase  							=      self.feature_extractor
  lowerCAmelCase  							=      False





