
'''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__					:						str											=     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__					:						List[str]											=     _LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)
def       lowerCAmelCase_		( SCREAMING_SNAKE_CASE_  )   ->   Optional[Any]:




   """simple docstring"""
   for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
      if class_name in processors:
         _SCREAMING_SNAKE_CASE          = model_type_to_module_name(SCREAMING_SNAKE_CASE_  )

         _SCREAMING_SNAKE_CASE          = importlib.import_module(F".{module_name}"			,					"""transformers.models"""  )
         try:
            return getattr(SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_  )
         except AttributeError:
            continue

   for processor in PROCESSOR_MAPPING._extra_content.values():
      if getattr(SCREAMING_SNAKE_CASE_			,					"""__name__"""			,					SCREAMING_SNAKE_CASE_  ) == 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.
   _SCREAMING_SNAKE_CASE          = importlib.import_module("""transformers"""  )
   if hasattr(SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_  ):
      return getattr(SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_  )

   return None







class       _a :





       """simple docstring"""




       def __init__(							self					)			->	Union[str, Any]:
          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(A__					)
       def 				UpperCamelCase (							cls				,							A__				,							**A__					)			->	Optional[Any]:
          _SCREAMING_SNAKE_CASE          = kwargs.pop("""config"""				,							A__					)
          _SCREAMING_SNAKE_CASE          = kwargs.pop("""trust_remote_code"""				,							A__					)
          _SCREAMING_SNAKE_CASE          = True

          _SCREAMING_SNAKE_CASE          = None
          _SCREAMING_SNAKE_CASE          = None

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

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

                _SCREAMING_SNAKE_CASE          = config_dict.get("""processor_class"""				,							A__					)
                if "AutoProcessor" in config_dict.get("""auto_map"""				,							{}					):
                   _SCREAMING_SNAKE_CASE          = config_dict["""auto_map"""]["""AutoProcessor"""]

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

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

          if processor_class is not None:
             _SCREAMING_SNAKE_CASE          = processor_class_from_name(A__					)

          _SCREAMING_SNAKE_CASE          = processor_auto_map is not None
          _SCREAMING_SNAKE_CASE          = processor_class is not None or type(A__					) in PROCESSOR_MAPPING
          _SCREAMING_SNAKE_CASE          = resolve_trust_remote_code(
              A__				,							A__				,							A__				,							A__					)

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

          # 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(
                 A__				,							trust_remote_code=A__				,							**A__					)
          except Exception:
             try:
                return AutoImageProcessor.from_pretrained(
                    A__				,							trust_remote_code=A__				,							**A__					)
             except Exception:
                pass

             try:
                return AutoFeatureExtractor.from_pretrained(
                    A__				,							trust_remote_code=A__				,							**A__					)
             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 (							A__				,							A__					)			->	Any:
          PROCESSOR_MAPPING.register(A__				,							A__					)








"""simple docstring"""




# Lint as: python3

import hashlib
from typing import Union

def   UpperCamelCase_  (		SCREAMING_SNAKE_CASE_			):
					if isinstance(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			):
										# Data already in bytes, returns as it as
										return hash_data
					elif isinstance(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			):
										# We keep the data as it as for it ot be later encoded to UTF-8
										# However replace `\\` with `/` for Windows compatibility
										SCREAMING_SNAKE_CASE				=	hash_data.replace('\\',     '/'			)
					elif isinstance(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			):
										SCREAMING_SNAKE_CASE				=	str(SCREAMING_SNAKE_CASE_			)
					else:
										# If data is not of the required type, raise error
										raise InvalidKeyError(SCREAMING_SNAKE_CASE_			)

					return hash_data.encode('utf-8'			)




class      UpperCamelCase	(       __magic_name__      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__			)    ->    Dict:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	'\nFAILURE TO GENERATE DATASET: Invalid key type detected'
									SCREAMING_SNAKE_CASE				=	f'''\nFound Key {hash_data} of type {type(lowercase__			)}'''
									SCREAMING_SNAKE_CASE				=	'\nKeys should be either str, int or bytes type'
									super().__init__(f'''{self.prefix}{self.err_msg}{self.suffix}'''			)






class      UpperCamelCase	(       __magic_name__      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	lowercase__		,	lowercase__=""			)    ->    Tuple:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	key
									SCREAMING_SNAKE_CASE				=	duplicate_key_indices
									SCREAMING_SNAKE_CASE				=	fix_msg
									SCREAMING_SNAKE_CASE				=	'Found multiple examples generated with the same key'
									if len(lowercase__			) <= 20:
														SCREAMING_SNAKE_CASE				=	f'''\nThe examples at index {', '.join(lowercase__			)} have the key {key}'''
									else:
														SCREAMING_SNAKE_CASE				=	f'''\nThe examples at index {', '.join(duplicate_key_indices[:20]			)}... ({len(lowercase__			) - 20} more) have the key {key}'''
									SCREAMING_SNAKE_CASE				=	'\n' + fix_msg if fix_msg else ''
									super().__init__(f'''{self.prefix}{self.err_msg}{self.suffix}'''			)






class      UpperCamelCase	:

				"""simple docstring"""



				def __init__(				self		,	lowercase__			)    ->    Union[str, Any]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	hashlib.mda(_as_bytes(lowercase__			)			)




				def 							A					(				self		,	lowercase__			)    ->    int:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self._split_mda.copy()
									SCREAMING_SNAKE_CASE				=	_as_bytes(lowercase__			)
									mda.update(lowercase__			)
									# Convert to integer with hexadecimal conversion
									return int(mda.hexdigest()		,	16			)
