




"""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


_lowercase		 =      logging.get_logger(__name__)

_lowercase		 =      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"""),
    ]
)

_lowercase		 =      _LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)

def 						lowerCAmelCase							(	lowerCamelCase						):
						'''simple docstring'''


						for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
												if class_name in processors:
																		snake_case__    :   List[Any]							     =   model_type_to_module_name(A__						)

																		snake_case__    :   Any							     =   importlib.import_module(f'''.{module_name}''' ,     '''transformers.models'''						)
																		try:
																								return getattr(A__ ,     A__						)
																		except AttributeError:
																								continue

						for processor in PROCESSOR_MAPPING._extra_content.values():
												if getattr(A__ ,     '''__name__''' ,     A__						) == 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.
						snake_case__    :   Optional[int]							     =   importlib.import_module('''transformers'''						)
						if hasattr(A__ ,     A__						):
												return getattr(A__ ,     A__						)

						return None

class  __lowercase    :


				'''simple docstring'''


				def __init__(				self				:       List[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(__UpperCamelCase )
				def  _lowerCamelCase   (				cls				:       Tuple ,SCREAMING_SNAKE_CASE_				:       Optional[Any] ,**SCREAMING_SNAKE_CASE_				:       int ):
										snake_case__    :   Any							     =   kwargs.pop('''config''' ,__UpperCamelCase )
										snake_case__    :   Optional[int]							     =   kwargs.pop('''trust_remote_code''' ,__UpperCamelCase )
										snake_case__    :   Tuple							     =   True

										snake_case__    :   List[Any]							     =   None
										snake_case__    :   Optional[int]							     =   None

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

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

																						snake_case__    :   List[str]							     =   config_dict.get('''processor_class''' ,__UpperCamelCase )
																						if "AutoProcessor" in config_dict.get('''auto_map''' ,{} ):
																												snake_case__    :   Optional[Any]							     =   config_dict['auto_map']['AutoProcessor']

										if processor_class is None:
																# Otherwise, load config, if it can be loaded.
																if not isinstance(__UpperCamelCase ,__UpperCamelCase ):
																						snake_case__    :   Optional[int]							     =   AutoConfig.from_pretrained(
																						    __UpperCamelCase ,trust_remote_code=__UpperCamelCase ,**__UpperCamelCase )

																# And check if the config contains the processor class.
																snake_case__    :   Optional[Any]							     =   getattr(__UpperCamelCase ,'''processor_class''' ,__UpperCamelCase )
																if hasattr(__UpperCamelCase ,'''auto_map''' ) and "AutoProcessor" in config.auto_map:
																						snake_case__    :   str							     =   config.auto_map['AutoProcessor']

										if processor_class is not None:
																snake_case__    :   Optional[int]							     =   processor_class_from_name(__UpperCamelCase )

										snake_case__    :   Any							     =   processor_auto_map is not None
										snake_case__    :   Optional[int]							     =   processor_class is not None or type(__UpperCamelCase ) in PROCESSOR_MAPPING
										snake_case__    :   Union[str, Any]							     =   resolve_trust_remote_code(
										    __UpperCamelCase ,__UpperCamelCase ,__UpperCamelCase ,__UpperCamelCase )

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

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

																try:
																						return AutoFeatureExtractor.from_pretrained(
																						    __UpperCamelCase ,trust_remote_code=__UpperCamelCase ,**__UpperCamelCase )
																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  _lowerCamelCase   (				SCREAMING_SNAKE_CASE_				:       Optional[Any] ,SCREAMING_SNAKE_CASE_				:       str ):
										PROCESSOR_MAPPING.register(__UpperCamelCase ,__UpperCamelCase )








"""simple docstring"""





def 						lowerCAmelCase							(	lowerCamelCase						):
						'''simple docstring'''


						return int(lowerCamelCase						) if x - int(lowerCamelCase						) <= 0 else int(lowerCamelCase						) + 1


if __name__ == "__main__":
							import doctest

							doctest.testmod()


