






"""simple docstring"""







import argparse
import json
from collections import OrderedDict
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
lowerCAmelCase_		:			Tuple				   =					logging.get_logger(__name__)

# here we list all keys to be renamed (original name on the left, our name on the right)
lowerCAmelCase_		:			Optional[Any]				   =					[]
for i in range(6):
 # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
 rename_keys.append(
     (F'transformer.encoder.layers.{i}.self_attn.out_proj.weight', F'encoder.layers.{i}.self_attn.out_proj.weight')
 )
 rename_keys.append(
     (F'transformer.encoder.layers.{i}.self_attn.out_proj.bias', F'encoder.layers.{i}.self_attn.out_proj.bias')
 )
 rename_keys.append((F'transformer.encoder.layers.{i}.linear1.weight', F'encoder.layers.{i}.fc1.weight'))
 rename_keys.append((F'transformer.encoder.layers.{i}.linear1.bias', F'encoder.layers.{i}.fc1.bias'))
 rename_keys.append((F'transformer.encoder.layers.{i}.linear2.weight', F'encoder.layers.{i}.fc2.weight'))
 rename_keys.append((F'transformer.encoder.layers.{i}.linear2.bias', F'encoder.layers.{i}.fc2.bias'))
 rename_keys.append(
     (F'transformer.encoder.layers.{i}.norm1.weight', F'encoder.layers.{i}.self_attn_layer_norm.weight')
 )
 rename_keys.append((F'transformer.encoder.layers.{i}.norm1.bias', F'encoder.layers.{i}.self_attn_layer_norm.bias'))
 rename_keys.append((F'transformer.encoder.layers.{i}.norm2.weight', F'encoder.layers.{i}.final_layer_norm.weight'))
 rename_keys.append((F'transformer.encoder.layers.{i}.norm2.bias', F'encoder.layers.{i}.final_layer_norm.bias'))
 # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
 rename_keys.append(
     (F'transformer.decoder.layers.{i}.self_attn.out_proj.weight', F'decoder.layers.{i}.self_attn.out_proj.weight')
 )
 rename_keys.append(
     (F'transformer.decoder.layers.{i}.self_attn.out_proj.bias', F'decoder.layers.{i}.self_attn.out_proj.bias')
 )
 rename_keys.append(
     (
         F'transformer.decoder.layers.{i}.multihead_attn.out_proj.weight',
         F'decoder.layers.{i}.encoder_attn.out_proj.weight',
     )
 )
 rename_keys.append(
     (
         F'transformer.decoder.layers.{i}.multihead_attn.out_proj.bias',
         F'decoder.layers.{i}.encoder_attn.out_proj.bias',
     )
 )
 rename_keys.append((F'transformer.decoder.layers.{i}.linear1.weight', F'decoder.layers.{i}.fc1.weight'))
 rename_keys.append((F'transformer.decoder.layers.{i}.linear1.bias', F'decoder.layers.{i}.fc1.bias'))
 rename_keys.append((F'transformer.decoder.layers.{i}.linear2.weight', F'decoder.layers.{i}.fc2.weight'))
 rename_keys.append((F'transformer.decoder.layers.{i}.linear2.bias', F'decoder.layers.{i}.fc2.bias'))
 rename_keys.append(
     (F'transformer.decoder.layers.{i}.norm1.weight', F'decoder.layers.{i}.self_attn_layer_norm.weight')
 )
 rename_keys.append((F'transformer.decoder.layers.{i}.norm1.bias', F'decoder.layers.{i}.self_attn_layer_norm.bias'))
 rename_keys.append(
     (F'transformer.decoder.layers.{i}.norm2.weight', F'decoder.layers.{i}.encoder_attn_layer_norm.weight')
 )
 rename_keys.append(
     (F'transformer.decoder.layers.{i}.norm2.bias', F'decoder.layers.{i}.encoder_attn_layer_norm.bias')
 )
 rename_keys.append((F'transformer.decoder.layers.{i}.norm3.weight', F'decoder.layers.{i}.final_layer_norm.weight'))
 rename_keys.append((F'transformer.decoder.layers.{i}.norm3.bias', F'decoder.layers.{i}.final_layer_norm.bias'))

# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
rename_keys.extend(
    [
        ('''input_proj.weight''', '''input_projection.weight'''),
        ('''input_proj.bias''', '''input_projection.bias'''),
        ('''query_embed.weight''', '''query_position_embeddings.weight'''),
        ('''transformer.decoder.norm.weight''', '''decoder.layernorm.weight'''),
        ('''transformer.decoder.norm.bias''', '''decoder.layernorm.bias'''),
        ('''class_embed.weight''', '''class_labels_classifier.weight'''),
        ('''class_embed.bias''', '''class_labels_classifier.bias'''),
        ('''bbox_embed.layers.0.weight''', '''bbox_predictor.layers.0.weight'''),
        ('''bbox_embed.layers.0.bias''', '''bbox_predictor.layers.0.bias'''),
        ('''bbox_embed.layers.1.weight''', '''bbox_predictor.layers.1.weight'''),
        ('''bbox_embed.layers.1.bias''', '''bbox_predictor.layers.1.bias'''),
        ('''bbox_embed.layers.2.weight''', '''bbox_predictor.layers.2.weight'''),
        ('''bbox_embed.layers.2.bias''', '''bbox_predictor.layers.2.bias'''),
    ]
)






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       UpperCAmelCase					=	state_dict.pop(__UpperCamelCase						)
       UpperCAmelCase					=	val






def 					_lowerCAmelCase				(					lowerCAmelCase						):







       '''simple docstring'''
       UpperCAmelCase					=	OrderedDict()
       for key, value in state_dict.items():
              if "backbone.0.body" in key:
                     UpperCAmelCase					=	key.replace("""backbone.0.body"""		,					"""backbone.conv_encoder.model"""						)
                     UpperCAmelCase					=	value
              else:
                     UpperCAmelCase					=	value

       return new_state_dict






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase=False						):







       '''simple docstring'''
       UpperCAmelCase					=	""""""
       if is_panoptic:
              UpperCAmelCase					=	"""detr."""

       # first: transformer encoder
       for i in range(6						):
              # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
              UpperCAmelCase					=	state_dict.pop(F'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'''						)
              UpperCAmelCase					=	state_dict.pop(F'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias'''						)
              # next, add query, keys and values (in that order) to the state dict
              UpperCAmelCase					=	in_proj_weight[:256, :]
              UpperCAmelCase					=	in_proj_bias[:256]
              UpperCAmelCase					=	in_proj_weight[256:512, :]
              UpperCAmelCase					=	in_proj_bias[256:512]
              UpperCAmelCase					=	in_proj_weight[-256:, :]
              UpperCAmelCase					=	in_proj_bias[-256:]
       # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
       for i in range(6						):
              # read in weights + bias of input projection layer of self-attention
              UpperCAmelCase					=	state_dict.pop(F'''{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight'''						)
              UpperCAmelCase					=	state_dict.pop(F'''{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias'''						)
              # next, add query, keys and values (in that order) to the state dict
              UpperCAmelCase					=	in_proj_weight[:256, :]
              UpperCAmelCase					=	in_proj_bias[:256]
              UpperCAmelCase					=	in_proj_weight[256:512, :]
              UpperCAmelCase					=	in_proj_bias[256:512]
              UpperCAmelCase					=	in_proj_weight[-256:, :]
              UpperCAmelCase					=	in_proj_bias[-256:]
              # read in weights + bias of input projection layer of cross-attention
              UpperCAmelCase					=	state_dict.pop(
                  F'''{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight'''						)
              UpperCAmelCase					=	state_dict.pop(F'''{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias'''						)
              # next, add query, keys and values (in that order) of cross-attention to the state dict
              UpperCAmelCase					=	in_proj_weight_cross_attn[:256, :]
              UpperCAmelCase					=	in_proj_bias_cross_attn[:256]
              UpperCAmelCase					=	in_proj_weight_cross_attn[256:512, :]
              UpperCAmelCase					=	in_proj_bias_cross_attn[256:512]
              UpperCAmelCase					=	in_proj_weight_cross_attn[-256:, :]
              UpperCAmelCase					=	in_proj_bias_cross_attn[-256:]






def 					_lowerCAmelCase				(					):







       '''simple docstring'''
       UpperCAmelCase					=	"""http://images.cocodataset.org/val2017/000000039769.jpg"""
       UpperCAmelCase					=	Image.open(requests.get(__UpperCamelCase		,					stream=__UpperCamelCase						).raw						)

       return im






@torch.no_grad()
def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       UpperCAmelCase					=	DetrConfig()
       # set backbone and dilation attributes
       if "resnet101" in model_name:
              UpperCAmelCase					=	"""resnet101"""
       if "dc5" in model_name:
              UpperCAmelCase					=	True
       UpperCAmelCase					=	"""panoptic""" in model_name
       if is_panoptic:
              UpperCAmelCase					=	250
       else:
              UpperCAmelCase					=	91
              UpperCAmelCase					=	"""huggingface/label-files"""
              UpperCAmelCase					=	"""coco-detection-id2label.json"""
              UpperCAmelCase					=	json.load(open(hf_hub_download(__UpperCamelCase		,					__UpperCamelCase		,					repo_type="""dataset"""						)		,					"""r"""						)						)
              UpperCAmelCase					=	{int(__UpperCamelCase						): v for k, v in idalabel.items()}
              UpperCAmelCase					=	idalabel
              UpperCAmelCase					=	{v: k for k, v in idalabel.items()}

       # load image processor
       UpperCAmelCase					=	"""coco_panoptic""" if is_panoptic else """coco_detection"""
       UpperCAmelCase					=	DetrImageProcessor(format=__UpperCamelCase						)

       # prepare image
       UpperCAmelCase					=	prepare_img()
       UpperCAmelCase					=	image_processor(images=__UpperCamelCase		,					return_tensors="""pt"""						)
       UpperCAmelCase					=	encoding["""pixel_values"""]

       logger.info(F'''Converting model {model_name}...'''						)

       # load original model from torch hub
       UpperCAmelCase					=	torch.hub.load("""facebookresearch/detr"""		,					__UpperCamelCase		,					pretrained=__UpperCamelCase						).eval()
       UpperCAmelCase					=	detr.state_dict()
       # rename keys
       for src, dest in rename_keys:
              if is_panoptic:
                     UpperCAmelCase					=	"""detr.""" + src
              rename_key(__UpperCamelCase		,					__UpperCamelCase		,					__UpperCamelCase						)
       UpperCAmelCase					=	rename_backbone_keys(__UpperCamelCase						)
       # query, key and value matrices need special treatment
       read_in_q_k_v(__UpperCamelCase		,					is_panoptic=__UpperCamelCase						)
       # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
       UpperCAmelCase					=	"""detr.model.""" if is_panoptic else """model."""
       for key in state_dict.copy().keys():
              if is_panoptic:
                     if (
                         key.startswith("""detr"""						)
                         and not key.startswith("""class_labels_classifier"""						)
                         and not key.startswith("""bbox_predictor"""						)
                     ):
                            UpperCAmelCase					=	state_dict.pop(__UpperCamelCase						)
                            UpperCAmelCase					=	val
                     elif "class_labels_classifier" in key or "bbox_predictor" in key:
                            UpperCAmelCase					=	state_dict.pop(__UpperCamelCase						)
                            UpperCAmelCase					=	val
                     elif key.startswith("""bbox_attention"""						) or key.startswith("""mask_head"""						):
                            continue
                     else:
                            UpperCAmelCase					=	state_dict.pop(__UpperCamelCase						)
                            UpperCAmelCase					=	val
              else:
                     if not key.startswith("""class_labels_classifier"""						) and not key.startswith("""bbox_predictor"""						):
                            UpperCAmelCase					=	state_dict.pop(__UpperCamelCase						)
                            UpperCAmelCase					=	val
    # finally, create HuggingFace model and load state dict
       UpperCAmelCase					=	DetrForSegmentation(__UpperCamelCase						) if is_panoptic else DetrForObjectDetection(__UpperCamelCase						)
       model.load_state_dict(__UpperCamelCase						)
       model.eval()
       # verify our conversion
       UpperCAmelCase					=	detr(__UpperCamelCase						)
       UpperCAmelCase					=	model(__UpperCamelCase						)
       assert torch.allclose(outputs.logits		,					original_outputs["""pred_logits"""]		,					atol=1e-4						)
       assert torch.allclose(outputs.pred_boxes		,					original_outputs["""pred_boxes"""]		,					atol=1e-4						)
       if is_panoptic:
              assert torch.allclose(outputs.pred_masks		,					original_outputs["""pred_masks"""]		,					atol=1e-4						)

       # Save model and image processor
       logger.info(F'''Saving PyTorch model and image processor to {pytorch_dump_folder_path}...'''						)
       Path(__UpperCamelCase						).mkdir(exist_ok=__UpperCamelCase						)
       model.save_pretrained(__UpperCamelCase						)
       image_processor.save_pretrained(__UpperCamelCase						)


if __name__ == "__main__":
 lowerCAmelCase_		:			List[Any]				   =					argparse.ArgumentParser()

 parser.add_argument(
     '''--model_name''', default='''detr_resnet50''', type=str, help='''Name of the DETR model you\'d like to convert.'''
 )
 parser.add_argument(
     '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the folder to output PyTorch model.'''
 )
 lowerCAmelCase_		:			List[str]				   =					parser.parse_args()
 convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path)


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


__A       						=       logging.get_logger(__name__)

__A       						=       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'),
    ]
)

__A       						=       _LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)



def     _lowerCamelCase(__UpperCamelCase       )				-> Optional[int]:
	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 		lowerCamelCase__					:





			'''simple docstring'''



			def __init__(							self  ) ->     str:
				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     ,     __UpperCAmelCase     ,     **__UpperCAmelCase  ) ->     Tuple:
				_lowerCAmelCase								=kwargs.pop("""config"""     ,     __UpperCAmelCase  )
				_lowerCAmelCase								=kwargs.pop("""trust_remote_code"""     ,     __UpperCAmelCase  )
				_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(__UpperCAmelCase  ).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(
				    __UpperCAmelCase     ,     __UpperCAmelCase     ,     **__UpperCAmelCase  )
				if preprocessor_config_file is not None:
					_lowerCAmelCase						,							_lowerCAmelCase								=ImageProcessingMixin.get_image_processor_dict(__UpperCAmelCase     ,     **__UpperCAmelCase  )
					_lowerCAmelCase								=config_dict.get("""processor_class"""     ,     __UpperCAmelCase  )
					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(__UpperCAmelCase     ,     **__UpperCAmelCase  )
					_lowerCAmelCase								=config_dict.get("""processor_class"""     ,     __UpperCAmelCase  )
					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(
					    __UpperCAmelCase     ,     __UpperCAmelCase     ,     **__UpperCAmelCase  )
					if tokenizer_config_file is not None:
						with open(__UpperCAmelCase     ,     encoding="""utf-8"""  ) as reader:
							_lowerCAmelCase								=json.load(__UpperCAmelCase  )

						_lowerCAmelCase								=config_dict.get("""processor_class"""     ,     __UpperCAmelCase  )
						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(__UpperCAmelCase     ,     __UpperCAmelCase  ):
						_lowerCAmelCase								=AutoConfig.from_pretrained(
						    __UpperCAmelCase     ,     trust_remote_code=__UpperCAmelCase     ,     **__UpperCAmelCase  )

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

				if processor_class is not None:
					_lowerCAmelCase								=processor_class_from_name(__UpperCAmelCase  )

				_lowerCAmelCase								=processor_auto_map is not None
				_lowerCAmelCase								=processor_class is not None or type(__UpperCAmelCase  ) in PROCESSOR_MAPPING
				_lowerCAmelCase								=resolve_trust_remote_code(
				    __UpperCAmelCase     ,     __UpperCAmelCase     ,     __UpperCAmelCase     ,     __UpperCAmelCase  )

				if has_remote_code and trust_remote_code:
					_lowerCAmelCase								=get_class_from_dynamic_module(
					    __UpperCAmelCase     ,     __UpperCAmelCase     ,     **__UpperCAmelCase  )
					_lowerCAmelCase								=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		(							__UpperCAmelCase     ,     __UpperCAmelCase  ) ->     Optional[int]:
				PROCESSOR_MAPPING.register(__UpperCAmelCase     ,     __UpperCAmelCase  )



