
import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
_A  =	{"LayoutLMv2Config", "LayoutLMv3Config"}





@is_pipeline_test
class       _lowerCAmelCase   (      unittest.TestCase			):
				_lowercase     						=MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
				_lowercase     						=TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

				if model_mapping is not None:
								_lowercase     						={config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
				if tf_model_mapping is not None:
								_lowercase     						={
								    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
								}




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase	)							-> Optional[int]:
							lowerCAmelCase_         =      ZeroShotClassificationPipeline(
							    model=_UpperCamelCase							,							tokenizer=_UpperCamelCase							,							candidate_labels=["polics", "health"]	)
							return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase	)							-> int:
							lowerCAmelCase_         =      classifier("Who are you voting for in 2020?"							,							candidate_labels="politics"	)
							self.assertEqual(_UpperCamelCase							,							{"sequence": ANY(_UpperCamelCase	), "labels": [ANY(_UpperCamelCase	)], "scores": [ANY(_UpperCamelCase	)]}	)

							# No kwarg
							lowerCAmelCase_         =      classifier("Who are you voting for in 2020?"							,							["politics"]	)
							self.assertEqual(_UpperCamelCase							,							{"sequence": ANY(_UpperCamelCase	), "labels": [ANY(_UpperCamelCase	)], "scores": [ANY(_UpperCamelCase	)]}	)

							lowerCAmelCase_         =      classifier("Who are you voting for in 2020?"							,							candidate_labels=["politics"]	)
							self.assertEqual(_UpperCamelCase							,							{"sequence": ANY(_UpperCamelCase	), "labels": [ANY(_UpperCamelCase	)], "scores": [ANY(_UpperCamelCase	)]}	)

							lowerCAmelCase_         =      classifier("Who are you voting for in 2020?"							,							candidate_labels="politics, public health"	)
							self.assertEqual(
							    _UpperCamelCase							,							{"sequence": ANY(_UpperCamelCase	), "labels": [ANY(_UpperCamelCase	), ANY(_UpperCamelCase	)], "scores": [ANY(_UpperCamelCase	), ANY(_UpperCamelCase	)]}	)
							self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]	)	)							,							1.0	)

							lowerCAmelCase_         =      classifier("Who are you voting for in 2020?"							,							candidate_labels=["politics", "public health"]	)
							self.assertEqual(
							    _UpperCamelCase							,							{"sequence": ANY(_UpperCamelCase	), "labels": [ANY(_UpperCamelCase	), ANY(_UpperCamelCase	)], "scores": [ANY(_UpperCamelCase	), ANY(_UpperCamelCase	)]}	)
							self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]	)	)							,							1.0	)

							lowerCAmelCase_         =      classifier(
							    "Who are you voting for in 2020?"							,							candidate_labels="politics"							,							hypothesis_template="This text is about {}"	)
							self.assertEqual(_UpperCamelCase							,							{"sequence": ANY(_UpperCamelCase	), "labels": [ANY(_UpperCamelCase	)], "scores": [ANY(_UpperCamelCase	)]}	)

							# https://github.com/huggingface/transformers/issues/13846
							lowerCAmelCase_         =      classifier(["I am happy"]							,							["positive", "negative"]	)
							self.assertEqual(
							    _UpperCamelCase							,							[
							        {"sequence": ANY(_UpperCamelCase	), "labels": [ANY(_UpperCamelCase	), ANY(_UpperCamelCase	)], "scores": [ANY(_UpperCamelCase	), ANY(_UpperCamelCase	)]}
							        for i in range(1	)
							    ]							,							)
							lowerCAmelCase_         =      classifier(["I am happy", "I am sad"]							,							["positive", "negative"]	)
							self.assertEqual(
							    _UpperCamelCase							,							[
							        {"sequence": ANY(_UpperCamelCase	), "labels": [ANY(_UpperCamelCase	), ANY(_UpperCamelCase	)], "scores": [ANY(_UpperCamelCase	), ANY(_UpperCamelCase	)]}
							        for i in range(2	)
							    ]							,							)

							with self.assertRaises(_UpperCamelCase	):
										classifier(""							,							candidate_labels="politics"	)

							with self.assertRaises(_UpperCamelCase	):
										classifier(_UpperCamelCase							,							candidate_labels="politics"	)

							with self.assertRaises(_UpperCamelCase	):
										classifier("Who are you voting for in 2020?"							,							candidate_labels=""	)

							with self.assertRaises(_UpperCamelCase	):
										classifier("Who are you voting for in 2020?"							,							candidate_labels=_UpperCamelCase	)

							with self.assertRaises(_UpperCamelCase	):
										classifier(
										    "Who are you voting for in 2020?"							,							candidate_labels="politics"							,							hypothesis_template="Not formatting template"							,							)

							with self.assertRaises(_UpperCamelCase	):
										classifier(
										    "Who are you voting for in 2020?"							,							candidate_labels="politics"							,							hypothesis_template=_UpperCamelCase							,							)

							self.run_entailment_id(_UpperCamelCase	)




				def 	__a		(   self							,							_UpperCamelCase	)							-> str:
							lowerCAmelCase_         =      zero_shot_classifier.model.config
							lowerCAmelCase_         =      config.labelaid
							lowerCAmelCase_         =      zero_shot_classifier.entailment_id

							lowerCAmelCase_         =      {"LABEL_0": 0, "LABEL_1": 1, "LABEL_2": 2}
							self.assertEqual(zero_shot_classifier.entailment_id							,							-1	)

							lowerCAmelCase_         =      {"entailment": 0, "neutral": 1, "contradiction": 2}
							self.assertEqual(zero_shot_classifier.entailment_id							,							0	)

							lowerCAmelCase_         =      {"ENTAIL": 0, "NON-ENTAIL": 1}
							self.assertEqual(zero_shot_classifier.entailment_id							,							0	)

							lowerCAmelCase_         =      {"ENTAIL": 2, "NEUTRAL": 1, "CONTR": 0}
							self.assertEqual(zero_shot_classifier.entailment_id							,							2	)

							lowerCAmelCase_         =      original_labelaid
							self.assertEqual(_UpperCamelCase							,							zero_shot_classifier.entailment_id	)




				@require_torch
				def 	__a		(   self	)							-> int:
							lowerCAmelCase_         =      pipeline(
							    "zero-shot-classification"							,							model="sshleifer/tiny-distilbert-base-cased-distilled-squad"							,							framework="pt"							,							)
							# There was a regression in 4.10 for this
							# Adding a test so we don't make the mistake again.
							# https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
							zero_shot_classifier(
							    "Who are you voting for in 2020?" * 100							,							candidate_labels=["politics", "public health", "science"]	)




				@require_torch
				def 	__a		(   self	)							-> Union[str, Any]:
							lowerCAmelCase_         =      pipeline(
							    "zero-shot-classification"							,							model="sshleifer/tiny-distilbert-base-cased-distilled-squad"							,							framework="pt"							,							)
							lowerCAmelCase_         =      zero_shot_classifier(
							    "Who are you voting for in 2020?"							,							candidate_labels=["politics", "public health", "science"]	)

							self.assertEqual(
							    nested_simplify(_UpperCamelCase	)							,							{
							        "sequence": "Who are you voting for in 2020?",
							        "labels": ["science", "public health", "politics"],
							        "scores": [0.333, 0.333, 0.333],
							    }							,							)




				@require_tf
				def 	__a		(   self	)							-> str:
							lowerCAmelCase_         =      pipeline(
							    "zero-shot-classification"							,							model="sshleifer/tiny-distilbert-base-cased-distilled-squad"							,							framework="tf"							,							)
							lowerCAmelCase_         =      zero_shot_classifier(
							    "Who are you voting for in 2020?"							,							candidate_labels=["politics", "public health", "science"]	)

							self.assertEqual(
							    nested_simplify(_UpperCamelCase	)							,							{
							        "sequence": "Who are you voting for in 2020?",
							        "labels": ["science", "public health", "politics"],
							        "scores": [0.333, 0.333, 0.333],
							    }							,							)




				@slow
				@require_torch
				def 	__a		(   self	)							-> List[str]:
							lowerCAmelCase_         =      pipeline("zero-shot-classification"							,							model="roberta-large-mnli"							,							framework="pt"	)
							lowerCAmelCase_         =      zero_shot_classifier(
							    "Who are you voting for in 2020?"							,							candidate_labels=["politics", "public health", "science"]	)

							self.assertEqual(
							    nested_simplify(_UpperCamelCase	)							,							{
							        "sequence": "Who are you voting for in 2020?",
							        "labels": ["politics", "public health", "science"],
							        "scores": [0.976, 0.015, 0.009],
							    }							,							)
							lowerCAmelCase_         =      zero_shot_classifier(
							    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
							    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
							    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
							    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
							    " machine translation tasks show these models to be superior in quality while being more parallelizable"
							    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
							    " English-to-German translation task, improving over the existing best results, including ensembles by"
							    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
							    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
							    " fraction of the training costs of the best models from the literature. We show that the Transformer"
							    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
							    " large and limited training data."							,							candidate_labels=["machine learning", "statistics", "translation", "vision"]							,							multi_label=_UpperCamelCase							,							)
							self.assertEqual(
							    nested_simplify(_UpperCamelCase	)							,							{
							        "sequence": (
							            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
							            " networks in an encoder-decoder configuration. The best performing models also connect the"
							            " encoder and decoder through an attention mechanism. We propose a new simple network"
							            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
							            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
							            " superior in quality while being more parallelizable and requiring significantly less time to"
							            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
							            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
							            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
							            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
							            " costs of the best models from the literature. We show that the Transformer generalizes well to"
							            " other tasks by applying it successfully to English constituency parsing both with large and"
							            " limited training data."
							        ),
							        "labels": ["translation", "machine learning", "vision", "statistics"],
							        "scores": [0.817, 0.713, 0.018, 0.018],
							    }							,							)




				@slow
				@require_tf
				def 	__a		(   self	)							-> Optional[int]:
							lowerCAmelCase_         =      pipeline("zero-shot-classification"							,							model="roberta-large-mnli"							,							framework="tf"	)
							lowerCAmelCase_         =      zero_shot_classifier(
							    "Who are you voting for in 2020?"							,							candidate_labels=["politics", "public health", "science"]	)

							self.assertEqual(
							    nested_simplify(_UpperCamelCase	)							,							{
							        "sequence": "Who are you voting for in 2020?",
							        "labels": ["politics", "public health", "science"],
							        "scores": [0.976, 0.015, 0.009],
							    }							,							)
							lowerCAmelCase_         =      zero_shot_classifier(
							    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
							    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
							    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
							    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
							    " machine translation tasks show these models to be superior in quality while being more parallelizable"
							    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
							    " English-to-German translation task, improving over the existing best results, including ensembles by"
							    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
							    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
							    " fraction of the training costs of the best models from the literature. We show that the Transformer"
							    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
							    " large and limited training data."							,							candidate_labels=["machine learning", "statistics", "translation", "vision"]							,							multi_label=_UpperCamelCase							,							)
							self.assertEqual(
							    nested_simplify(_UpperCamelCase	)							,							{
							        "sequence": (
							            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
							            " networks in an encoder-decoder configuration. The best performing models also connect the"
							            " encoder and decoder through an attention mechanism. We propose a new simple network"
							            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
							            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
							            " superior in quality while being more parallelizable and requiring significantly less time to"
							            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
							            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
							            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
							            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
							            " costs of the best models from the literature. We show that the Transformer generalizes well to"
							            " other tasks by applying it successfully to English constituency parsing both with large and"
							            " limited training data."
							        ),
							        "labels": ["translation", "machine learning", "vision", "statistics"],
							        "scores": [0.817, 0.713, 0.018, 0.018],
							    }							,							)





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 ChineseCLIPImageProcessor





class       _lowerCAmelCase   (      unittest.TestCase			):




				def __init__(   self							,							_UpperCamelCase							,							_UpperCamelCase=7							,							_UpperCamelCase=3							,							_UpperCamelCase=18							,							_UpperCamelCase=30							,							_UpperCamelCase=400							,							_UpperCamelCase=True							,							_UpperCamelCase=None							,							_UpperCamelCase=True							,							_UpperCamelCase=None							,							_UpperCamelCase=True							,							_UpperCamelCase=[0.48145466, 0.4578275, 0.40821073]							,							_UpperCamelCase=[0.26862954, 0.26130258, 0.27577711]							,							_UpperCamelCase=True							,							)							-> Dict:
							lowerCAmelCase_         =      size if size is not None else {"height": 224, "width": 224}
							lowerCAmelCase_         =      crop_size if crop_size is not None else {"height": 18, "width": 18}
							lowerCAmelCase_         =      parent
							lowerCAmelCase_         =      batch_size
							lowerCAmelCase_         =      num_channels
							lowerCAmelCase_         =      image_size
							lowerCAmelCase_         =      min_resolution
							lowerCAmelCase_         =      max_resolution
							lowerCAmelCase_         =      do_resize
							lowerCAmelCase_         =      size
							lowerCAmelCase_         =      do_center_crop
							lowerCAmelCase_         =      crop_size
							lowerCAmelCase_         =      do_normalize
							lowerCAmelCase_         =      image_mean
							lowerCAmelCase_         =      image_std
							lowerCAmelCase_         =      do_convert_rgb




				def 	__a		(   self	)							-> List[Any]:
							return {
							    "do_resize": self.do_resize,
							    "size": self.size,
							    "do_center_crop": self.do_center_crop,
							    "crop_size": self.crop_size,
							    "do_normalize": self.do_normalize,
							    "image_mean": self.image_mean,
							    "image_std": self.image_std,
							    "do_convert_rgb": self.do_convert_rgb,
							}




				def 	__a		(   self							,							_UpperCamelCase=False							,							_UpperCamelCase=False							,							_UpperCamelCase=False	)							-> Dict:
							assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

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

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

							if torchify:
										lowerCAmelCase_         =      [torch.from_numpy(_UpperCamelCase	) for x in image_inputs]

							return image_inputs





@require_torch
@require_vision
class       _lowerCAmelCase   (      __a   , unittest.TestCase			):
				_lowercase     						=ChineseCLIPImageProcessor if is_vision_available() else None




				def 	__a		(   self	)							-> Union[str, Any]:
							lowerCAmelCase_         =      ChineseCLIPImageProcessingTester(self							,							do_center_crop=_UpperCamelCase	)




				@property
				def 	__a		(   self	)							-> Tuple:
							return self.image_processor_tester.prepare_image_processor_dict()




				def 	__a		(   self	)							-> Any:
							lowerCAmelCase_         =      self.image_processing_class(**self.image_processor_dict	)
							self.assertTrue(hasattr(_UpperCamelCase							,							"do_resize"	)	)
							self.assertTrue(hasattr(_UpperCamelCase							,							"size"	)	)
							self.assertTrue(hasattr(_UpperCamelCase							,							"do_center_crop"	)	)
							self.assertTrue(hasattr(_UpperCamelCase							,							"center_crop"	)	)
							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 	__a		(   self	)							-> List[str]:
							lowerCAmelCase_         =      self.image_processing_class.from_dict(self.image_processor_dict	)
							self.assertEqual(image_processor.size							,							{"height": 224, "width": 224}	)
							self.assertEqual(image_processor.crop_size							,							{"height": 18, "width": 18}	)

							lowerCAmelCase_         =      self.image_processing_class.from_dict(self.image_processor_dict							,							size=42							,							crop_size=84	)
							self.assertEqual(image_processor.size							,							{"shortest_edge": 42}	)
							self.assertEqual(image_processor.crop_size							,							{"height": 84, "width": 84}	)




				def 	__a		(   self	)							-> str:
							pass




				def 	__a		(   self	)							-> Any:
							# Initialize image_processing
							lowerCAmelCase_         =      self.image_processing_class(**self.image_processor_dict	)
							# create random PIL images
							lowerCAmelCase_         =      self.image_processor_tester.prepare_inputs(equal_resolution=_UpperCamelCase	)
							for image in image_inputs:
										self.assertIsInstance(_UpperCamelCase							,							Image.Image	)

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

							# Test batched
							lowerCAmelCase_         =      image_processing(_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.crop_size["height"],
							        self.image_processor_tester.crop_size["width"],
							    )							,							)




				def 	__a		(   self	)							-> str:
							# Initialize image_processing
							lowerCAmelCase_         =      self.image_processing_class(**self.image_processor_dict	)
							# create random numpy tensors
							lowerCAmelCase_         =      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
							lowerCAmelCase_         =      image_processing(image_inputs[0]							,							return_tensors="pt"	).pixel_values
							self.assertEqual(
							    encoded_images.shape							,							(
							        1,
							        self.image_processor_tester.num_channels,
							        self.image_processor_tester.crop_size["height"],
							        self.image_processor_tester.crop_size["width"],
							    )							,							)

							# Test batched
							lowerCAmelCase_         =      image_processing(_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.crop_size["height"],
							        self.image_processor_tester.crop_size["width"],
							    )							,							)




				def 	__a		(   self	)							-> Union[str, Any]:
							# Initialize image_processing
							lowerCAmelCase_         =      self.image_processing_class(**self.image_processor_dict	)
							# create random PyTorch tensors
							lowerCAmelCase_         =      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
							lowerCAmelCase_         =      image_processing(image_inputs[0]							,							return_tensors="pt"	).pixel_values
							self.assertEqual(
							    encoded_images.shape							,							(
							        1,
							        self.image_processor_tester.num_channels,
							        self.image_processor_tester.crop_size["height"],
							        self.image_processor_tester.crop_size["width"],
							    )							,							)

							# Test batched
							lowerCAmelCase_         =      image_processing(_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.crop_size["height"],
							        self.image_processor_tester.crop_size["width"],
							    )							,							)





@require_torch
@require_vision
class       _lowerCAmelCase   (      __a   , unittest.TestCase			):
				_lowercase     						=ChineseCLIPImageProcessor if is_vision_available() else None




				def 	__a		(   self	)							-> List[Any]:
							lowerCAmelCase_         =      ChineseCLIPImageProcessingTester(self							,							num_channels=4							,							do_center_crop=_UpperCamelCase	)
							lowerCAmelCase_         =      3




				@property
				def 	__a		(   self	)							-> List[str]:
							return self.image_processor_tester.prepare_image_processor_dict()




				def 	__a		(   self	)							-> Union[str, Any]:
							lowerCAmelCase_         =      self.image_processing_class(**self.image_processor_dict	)
							self.assertTrue(hasattr(_UpperCamelCase							,							"do_resize"	)	)
							self.assertTrue(hasattr(_UpperCamelCase							,							"size"	)	)
							self.assertTrue(hasattr(_UpperCamelCase							,							"do_center_crop"	)	)
							self.assertTrue(hasattr(_UpperCamelCase							,							"center_crop"	)	)
							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 	__a		(   self	)							-> int:
							pass




				def 	__a		(   self	)							-> str:
							# Initialize image_processing
							lowerCAmelCase_         =      self.image_processing_class(**self.image_processor_dict	)
							# create random PIL images
							lowerCAmelCase_         =      self.image_processor_tester.prepare_inputs(equal_resolution=_UpperCamelCase	)
							for image in image_inputs:
										self.assertIsInstance(_UpperCamelCase							,							Image.Image	)

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

							# Test batched
							lowerCAmelCase_         =      image_processing(_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.crop_size["height"],
							        self.image_processor_tester.crop_size["width"],
							    )							,							)



