



"""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()
_lowercase					:					Dict 		=		logging.get_logger(__name__)

# here we list all keys to be renamed (original name on the left, our name on the right)
_lowercase					:					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 	snake_case__  (						__lowerCamelCase							:       int				,						__lowerCamelCase							:       Dict				,						__lowerCamelCase							:       str      ):
			"""simple docstring"""
			lowerCamelCase__						:						Dict						      =state_dict.pop(__lowerCamelCase      )
			lowerCamelCase__						:						List[Any]						      =val






def 	snake_case__  (						__lowerCamelCase							:       Optional[int]      ):
			"""simple docstring"""
			lowerCamelCase__						:						Optional[Any]						      =OrderedDict()
			for key, value in state_dict.items():
						if "backbone.0.body" in key:
									lowerCamelCase__						:						int						      =key.replace('''backbone.0.body'''				,						'''backbone.conv_encoder.model'''      )
									lowerCamelCase__						:						str						      =value
						else:
									lowerCamelCase__						:						str						      =value

			return new_state_dict






def 	snake_case__  (						__lowerCamelCase							:       Any				,						__lowerCamelCase							:       Optional[int]=False      ):
			"""simple docstring"""
			lowerCamelCase__						:						List[Any]						      =''''''
			if is_panoptic:
						lowerCamelCase__						:						List[Any]						      ='''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)
						lowerCamelCase__						:						Tuple						      =state_dict.pop(f'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'''      )
						lowerCamelCase__						:						Optional[int]						      =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
						lowerCamelCase__						:						Dict						      =in_proj_weight[:256, :]
						lowerCamelCase__						:						Dict						      =in_proj_bias[:256]
						lowerCamelCase__						:						List[Any]						      =in_proj_weight[256:512, :]
						lowerCamelCase__						:						int						      =in_proj_bias[256:512]
						lowerCamelCase__						:						Dict						      =in_proj_weight[-256:, :]
						lowerCamelCase__						:						Tuple						      =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
						lowerCamelCase__						:						List[str]						      =state_dict.pop(f'''{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight'''      )
						lowerCamelCase__						:						Tuple						      =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
						lowerCamelCase__						:						Union[str, Any]						      =in_proj_weight[:256, :]
						lowerCamelCase__						:						int						      =in_proj_bias[:256]
						lowerCamelCase__						:						int						      =in_proj_weight[256:512, :]
						lowerCamelCase__						:						Optional[int]						      =in_proj_bias[256:512]
						lowerCamelCase__						:						Optional[Any]						      =in_proj_weight[-256:, :]
						lowerCamelCase__						:						Dict						      =in_proj_bias[-256:]
						# read in weights + bias of input projection layer of cross-attention
						lowerCamelCase__						:						Any						      =state_dict.pop(
						    f'''{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight'''      )
						lowerCamelCase__						:						List[Any]						      =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
						lowerCamelCase__						:						List[str]						      =in_proj_weight_cross_attn[:256, :]
						lowerCamelCase__						:						Union[str, Any]						      =in_proj_bias_cross_attn[:256]
						lowerCamelCase__						:						Union[str, Any]						      =in_proj_weight_cross_attn[256:512, :]
						lowerCamelCase__						:						List[Any]						      =in_proj_bias_cross_attn[256:512]
						lowerCamelCase__						:						Optional[Any]						      =in_proj_weight_cross_attn[-256:, :]
						lowerCamelCase__						:						Tuple						      =in_proj_bias_cross_attn[-256:]






def 	snake_case__  (						):
			"""simple docstring"""
			lowerCamelCase__						:						Optional[Any]						      ='''http://images.cocodataset.org/val2017/000000039769.jpg'''
			lowerCamelCase__						:						List[str]						      =Image.open(requests.get(__lowerCamelCase				,						stream=__lowerCamelCase      ).raw      )

			return im






@torch.no_grad()
def 	snake_case__  (						__lowerCamelCase							:       Dict				,						__lowerCamelCase							:       List[Any]      ):
			"""simple docstring"""
			lowerCamelCase__						:						str						      =DetrConfig()
			# set backbone and dilation attributes
			if "resnet101" in model_name:
						lowerCamelCase__						:						Union[str, Any]						      ='''resnet101'''
			if "dc5" in model_name:
						lowerCamelCase__						:						List[Any]						      =True
			lowerCamelCase__						:						List[str]						      ='''panoptic''' in model_name
			if is_panoptic:
						lowerCamelCase__						:						Union[str, Any]						      =250
			else:
						lowerCamelCase__						:						str						      =91
						lowerCamelCase__						:						List[str]						      ='''huggingface/label-files'''
						lowerCamelCase__						:						Union[str, Any]						      ='''coco-detection-id2label.json'''
						lowerCamelCase__						:						Optional[int]						      =json.load(open(hf_hub_download(__lowerCamelCase				,						__lowerCamelCase				,						repo_type='''dataset'''      )				,						'''r'''      )      )
						lowerCamelCase__						:						str						      ={int(__lowerCamelCase      ): v for k, v in idalabel.items()}
						lowerCamelCase__						:						Dict						      =idalabel
						lowerCamelCase__						:						int						      ={v: k for k, v in idalabel.items()}

			# load image processor
			lowerCamelCase__						:						Optional[Any]						      ='''coco_panoptic''' if is_panoptic else '''coco_detection'''
			lowerCamelCase__						:						Optional[int]						      =DetrImageProcessor(format=__lowerCamelCase      )

			# prepare image
			lowerCamelCase__						:						str						      =prepare_img()
			lowerCamelCase__						:						Optional[int]						      =image_processor(images=__lowerCamelCase				,						return_tensors='''pt'''      )
			lowerCamelCase__						:						Optional[Any]						      =encoding['''pixel_values''']

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

			# load original model from torch hub
			lowerCamelCase__						:						Optional[int]						      =torch.hub.load('''facebookresearch/detr'''				,						__lowerCamelCase				,						pretrained=__lowerCamelCase      ).eval()
			lowerCamelCase__						:						Dict						      =detr.state_dict()
			# rename keys
			for src, dest in rename_keys:
						if is_panoptic:
									lowerCamelCase__						:						Tuple						      ='''detr.''' + src
						rename_key(__lowerCamelCase				,						__lowerCamelCase				,						__lowerCamelCase      )
			lowerCamelCase__						:						str						      =rename_backbone_keys(__lowerCamelCase      )
			# query, key and value matrices need special treatment
			read_in_q_k_v(__lowerCamelCase				,						is_panoptic=__lowerCamelCase      )
			# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
			lowerCamelCase__						:						Tuple						      ='''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'''      )
									):
												lowerCamelCase__						:						List[Any]						      =state_dict.pop(__lowerCamelCase      )
												lowerCamelCase__						:						Dict						      =val
									elif "class_labels_classifier" in key or "bbox_predictor" in key:
												lowerCamelCase__						:						Optional[Any]						      =state_dict.pop(__lowerCamelCase      )
												lowerCamelCase__						:						List[str]						      =val
									elif key.startswith('''bbox_attention'''      ) or key.startswith('''mask_head'''      ):
												continue
									else:
												lowerCamelCase__						:						Optional[Any]						      =state_dict.pop(__lowerCamelCase      )
												lowerCamelCase__						:						Optional[int]						      =val
						else:
									if not key.startswith('''class_labels_classifier'''      ) and not key.startswith('''bbox_predictor'''      ):
												lowerCamelCase__						:						List[str]						      =state_dict.pop(__lowerCamelCase      )
												lowerCamelCase__						:						int						      =val
    # finally, create HuggingFace model and load state dict
			lowerCamelCase__						:						List[Any]						      =DetrForSegmentation(__lowerCamelCase      ) if is_panoptic else DetrForObjectDetection(__lowerCamelCase      )
			model.load_state_dict(__lowerCamelCase      )
			model.eval()
			# verify our conversion
			lowerCamelCase__						:						Dict						      =detr(__lowerCamelCase      )
			lowerCamelCase__						:						Union[str, Any]						      =model(__lowerCamelCase      )
			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(__lowerCamelCase      ).mkdir(exist_ok=__lowerCamelCase      )
			model.save_pretrained(__lowerCamelCase      )
			image_processor.save_pretrained(__lowerCamelCase      )


if __name__ == "__main__":
		_lowercase					:					Union[str, 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."
		)
		_lowercase					:					Optional[int] 		=		parser.parse_args()
		convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path)











"""simple docstring"""
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image

		from transformers import BlipImageProcessor






class    _UpperCAmelCase  (      unittest.TestCase					):


					def __init__(   self     :Optional[Any]	,			__UpperCamelCase     :Optional[int]	,			__UpperCamelCase     :Dict=7	,			__UpperCamelCase     :Optional[Any]=3	,			__UpperCamelCase     :Tuple=18	,			__UpperCamelCase     :List[Any]=30	,			__UpperCamelCase     :Optional[Any]=4_00	,			__UpperCamelCase     :Union[str, Any]=True	,			__UpperCamelCase     :Tuple=None	,			__UpperCamelCase     :List[str]=True	,			__UpperCamelCase     :Any=False	,			__UpperCamelCase     :str=[0.48_145_466, 0.4_578_275, 0.40_821_073]	,			__UpperCamelCase     :Optional[Any]=[0.26_862_954, 0.26_130_258, 0.27_577_711]	,			__UpperCamelCase     :Optional[Any]=True	,			):
												A						=    size if size is not None else {"height": 20, "width": 20}
												A						=    parent
												A						=    batch_size
												A						=    num_channels
												A						=    image_size
												A						=    min_resolution
												A						=    max_resolution
												A						=    do_resize
												A						=    size
												A						=    do_normalize
												A						=    image_mean
												A						=    image_std
												A						=    do_pad
												A						=    do_convert_rgb


					def       lowerCamelCase			(   self     :List[str]						):
												return {
												    "do_resize": self.do_resize,
												    "size": self.size,
												    "do_normalize": self.do_normalize,
												    "image_mean": self.image_mean,
												    "image_std": self.image_std,
												    "do_convert_rgb": self.do_convert_rgb,
												    "do_pad": self.do_pad,
												}


					def       lowerCamelCase			(   self     :Optional[Any]	,			__UpperCamelCase     :Optional[int]=False	,			__UpperCamelCase     :Dict=False	,			__UpperCamelCase     :Dict=False						):
												assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

												if equal_resolution:
																			A						=    []
																			for i in range(self.batch_size						):
																										image_inputs.append(
																										    np.random.randint(
																										        2_55	,			size=(self.num_channels, self.max_resolution, self.max_resolution)	,			dtype=np.uinta						)						)
												else:
																			A						=    []
																			for i in range(self.batch_size						):
																										A,      A						=    np.random.choice(np.arange(self.min_resolution	,			self.max_resolution						)	,			2						)
																										image_inputs.append(np.random.randint(2_55	,			size=(self.num_channels, width, height)	,			dtype=np.uinta						)						)

												if not numpify and not torchify:
																			# PIL expects the channel dimension as last dimension
																			A						=    [Image.fromarray(np.moveaxis(__UpperCamelCase	,			0	,			-1						)						) for x in image_inputs]

												if torchify:
																			A						=    [torch.from_numpy(__UpperCamelCase						) for x in image_inputs]

												return image_inputs







@require_torch
@require_vision
class    _UpperCAmelCase  (      lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				BlipImageProcessor if is_vision_available() else None


					def       lowerCamelCase			(   self     :Optional[Any]						):
												A						=    BlipImageProcessingTester(self						)


					@property
					def       lowerCamelCase			(   self     :List[str]						):
												return self.image_processor_tester.prepare_image_processor_dict()


					def       lowerCamelCase			(   self     :Any						):
												A						=    self.image_processing_class(**self.image_processor_dict						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_resize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"size"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_normalize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_mean"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_std"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_convert_rgb"						)						)


					def       lowerCamelCase			(   self     :List[Any]						):
												pass


					def       lowerCamelCase			(   self     :Optional[Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PIL images
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			Image.Image						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)


					def       lowerCamelCase			(   self     :Union[str, Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random numpy tensors
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase	,			numpify=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			np.ndarray						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)


					def       lowerCamelCase			(   self     :Tuple						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PyTorch tensors
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase	,			torchify=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			torch.Tensor						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)







@require_torch
@require_vision
class    _UpperCAmelCase  (      lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				BlipImageProcessor if is_vision_available() else None


					def       lowerCamelCase			(   self     :int						):
												A						=    BlipImageProcessingTester(self	,			num_channels=4						)
												A						=    3


					@property
					def       lowerCamelCase			(   self     :Optional[Any]						):
												return self.image_processor_tester.prepare_image_processor_dict()


					def       lowerCamelCase			(   self     :int						):
												A						=    self.image_processing_class(**self.image_processor_dict						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_resize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"size"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_normalize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_mean"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_std"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_convert_rgb"						)						)


					def       lowerCamelCase			(   self     :Any						):
												pass


					def       lowerCamelCase			(   self     :Optional[Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PIL images
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			Image.Image						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.expected_encoded_image_num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        self.image_processor_tester.batch_size,
												        self.expected_encoded_image_num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)


