




from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import (
				    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFXLMForMultipleChoice,
				    TFXLMForQuestionAnsweringSimple,
				    TFXLMForSequenceClassification,
				    TFXLMForTokenClassification,
				    TFXLMModel,
				    TFXLMWithLMHeadModel,
				    XLMConfig,
				)



class 			a_					:





	def __init__(       self			,    SCREAMING_SNAKE_CASE			,    )     ->				Optional[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	parent
				SCREAMING_SNAKE_CASE_			=	13
				SCREAMING_SNAKE_CASE_			=	7
				SCREAMING_SNAKE_CASE_			=	True
				SCREAMING_SNAKE_CASE_			=	True
				SCREAMING_SNAKE_CASE_			=	True
				SCREAMING_SNAKE_CASE_			=	True
				SCREAMING_SNAKE_CASE_			=	True
				SCREAMING_SNAKE_CASE_			=	False
				SCREAMING_SNAKE_CASE_			=	False
				SCREAMING_SNAKE_CASE_			=	False
				SCREAMING_SNAKE_CASE_			=	2
				SCREAMING_SNAKE_CASE_			=	99
				SCREAMING_SNAKE_CASE_			=	0
				SCREAMING_SNAKE_CASE_			=	32
				SCREAMING_SNAKE_CASE_			=	2
				SCREAMING_SNAKE_CASE_			=	4
				SCREAMING_SNAKE_CASE_			=	0.1
				SCREAMING_SNAKE_CASE_			=	0.1
				SCREAMING_SNAKE_CASE_			=	512
				SCREAMING_SNAKE_CASE_			=	16
				SCREAMING_SNAKE_CASE_			=	2
				SCREAMING_SNAKE_CASE_			=	0.0_2
				SCREAMING_SNAKE_CASE_			=	3
				SCREAMING_SNAKE_CASE_			=	4
				SCREAMING_SNAKE_CASE_			=	'''last'''
				SCREAMING_SNAKE_CASE_			=	True
				SCREAMING_SNAKE_CASE_			=	None
				SCREAMING_SNAKE_CASE_			=	0





	def 	A_(       self			)     ->				Union[str, Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size, self.seq_length]			,    self.vocab_size			)
				SCREAMING_SNAKE_CASE_			=	random_attention_mask([self.batch_size, self.seq_length]			,    dtype=tf.floataa			)

				SCREAMING_SNAKE_CASE_			=	None
				if self.use_input_lengths:
							SCREAMING_SNAKE_CASE_			=	(
							    ids_tensor([self.batch_size]			,    vocab_size=2			) + self.seq_length - 2
							)  # small variation of seq_length

				SCREAMING_SNAKE_CASE_			=	None
				if self.use_token_type_ids:
							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size, self.seq_length]			,    self.n_langs			)

				SCREAMING_SNAKE_CASE_			=	None
				SCREAMING_SNAKE_CASE_			=	None
				SCREAMING_SNAKE_CASE_			=	None
				if self.use_labels:
							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size]			,    self.type_sequence_label_size			)
							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size, self.seq_length]			,    self.num_labels			)
							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size]			,    2			,    dtype=tf.floataa			)
							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size]			,    self.num_choices			)

				SCREAMING_SNAKE_CASE_			=	XLMConfig(
				    vocab_size=self.vocab_size			,    n_special=self.n_special			,    emb_dim=self.hidden_size			,    n_layers=self.num_hidden_layers			,    n_heads=self.num_attention_heads			,    dropout=self.hidden_dropout_prob			,    attention_dropout=self.attention_probs_dropout_prob			,    gelu_activation=self.gelu_activation			,    sinusoidal_embeddings=self.sinusoidal_embeddings			,    asm=self.asm			,    causal=self.causal			,    n_langs=self.n_langs			,    max_position_embeddings=self.max_position_embeddings			,    initializer_range=self.initializer_range			,    summary_type=self.summary_type			,    use_proj=self.use_proj			,    bos_token_id=self.bos_token_id			,    )

				return (
				    config,
				    input_ids,
				    token_type_ids,
				    input_lengths,
				    sequence_labels,
				    token_labels,
				    is_impossible_labels,
				    choice_labels,
				    input_mask,
				)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				int:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	TFXLMModel(config=SCREAMING_SNAKE_CASE			)
				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)

				SCREAMING_SNAKE_CASE_			=	[input_ids, input_mask]
				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
				self.parent.assertEqual(result.last_hidden_state.shape			,    (self.batch_size, self.seq_length, self.hidden_size)			)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				Optional[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	TFXLMWithLMHeadModel(SCREAMING_SNAKE_CASE			)

				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)

				SCREAMING_SNAKE_CASE_			=	outputs

				self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.seq_length, self.vocab_size)			)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				str:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	TFXLMForQuestionAnsweringSimple(SCREAMING_SNAKE_CASE			)

				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''lengths''': input_lengths}

				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)

				self.parent.assertEqual(result.start_logits.shape			,    (self.batch_size, self.seq_length)			)
				self.parent.assertEqual(result.end_logits.shape			,    (self.batch_size, self.seq_length)			)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				int:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	TFXLMForSequenceClassification(SCREAMING_SNAKE_CASE			)

				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''lengths''': input_lengths}

				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)

				self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.type_sequence_label_size)			)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				int:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	self.num_labels
				SCREAMING_SNAKE_CASE_			=	TFXLMForTokenClassification(config=SCREAMING_SNAKE_CASE			)
				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
				self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.seq_length, self.num_labels)			)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				Dict:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	self.num_choices
				SCREAMING_SNAKE_CASE_			=	TFXLMForMultipleChoice(config=SCREAMING_SNAKE_CASE			)
				SCREAMING_SNAKE_CASE_			=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE			,    1			)			,    (1, self.num_choices, 1)			)
				SCREAMING_SNAKE_CASE_			=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE			,    1			)			,    (1, self.num_choices, 1)			)
				SCREAMING_SNAKE_CASE_			=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE			,    1			)			,    (1, self.num_choices, 1)			)
				SCREAMING_SNAKE_CASE_			=	{
				    '''input_ids''': multiple_choice_inputs_ids,
				    '''attention_mask''': multiple_choice_input_mask,
				    '''token_type_ids''': multiple_choice_token_type_ids,
				}
				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
				self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.num_choices)			)





	def 	A_(       self			)     ->				int:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	self.prepare_config_and_inputs()
				(
				    SCREAMING_SNAKE_CASE_	
				)			=	config_and_inputs
				SCREAMING_SNAKE_CASE_			=	{
				    '''input_ids''': input_ids,
				    '''token_type_ids''': token_type_ids,
				    '''langs''': token_type_ids,
				    '''lengths''': input_lengths,
				}
				return config, inputs_dict




@require_tf
class 			a_					(    A_     ,						A_     ,						unittest.TestCase    ):
	A						       =   (
	    (
	        TFXLMModel,
	        TFXLMWithLMHeadModel,
	        TFXLMForSequenceClassification,
	        TFXLMForQuestionAnsweringSimple,
	        TFXLMForTokenClassification,
	        TFXLMForMultipleChoice,
	    )
	    if is_tf_available()
	    else ()
	)
	A						       =   (
	    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	A						       =   (
	    {
	        '''feature-extraction''': TFXLMModel,
	        '''fill-mask''': TFXLMWithLMHeadModel,
	        '''question-answering''': TFXLMForQuestionAnsweringSimple,
	        '''text-classification''': TFXLMForSequenceClassification,
	        '''text-generation''': TFXLMWithLMHeadModel,
	        '''token-classification''': TFXLMForTokenClassification,
	        '''zero-shot''': TFXLMForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	A						       =   False
	A						       =   False





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)     ->				Tuple:




				"""simple docstring"""



				if (
				    pipeline_test_casse_name == "QAPipelineTests"
				    and tokenizer_name is not None
				    and not tokenizer_name.endswith('Fast'			)
				):
							# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
							# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
							# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
							return True

				return False





	def 	A_(       self			)     ->				str:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	TFXLMModelTester(self			)
				SCREAMING_SNAKE_CASE_			=	ConfigTester(self			,    config_class=SCREAMING_SNAKE_CASE			,    emb_dim=37			)





	def 	A_(       self			)     ->				Optional[Any]:




				"""simple docstring"""



				self.config_tester.run_common_tests()





	def 	A_(       self			)     ->				Any:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_model(*SCREAMING_SNAKE_CASE			)





	def 	A_(       self			)     ->				Union[str, Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_lm_head(*SCREAMING_SNAKE_CASE			)





	def 	A_(       self			)     ->				Dict:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_qa(*SCREAMING_SNAKE_CASE			)





	def 	A_(       self			)     ->				Dict:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_sequence_classif(*SCREAMING_SNAKE_CASE			)





	def 	A_(       self			)     ->				Optional[int]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_for_token_classification(*SCREAMING_SNAKE_CASE			)





	def 	A_(       self			)     ->				Dict:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_xlm_for_multiple_choice(*SCREAMING_SNAKE_CASE			)





	@slow
	def 	A_(       self			)     ->				str:




				"""simple docstring"""



				for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							SCREAMING_SNAKE_CASE_			=	TFXLMModel.from_pretrained(SCREAMING_SNAKE_CASE			)
							self.assertIsNotNone(SCREAMING_SNAKE_CASE			)




@require_tf
class 			a_					(    unittest.TestCase    ):





	@slow
	def 	A_(       self			)     ->				List[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'			)
				SCREAMING_SNAKE_CASE_			=	tf.convert_to_tensor([[14, 447]]			,    dtype=tf.intaa			)  # the president
				SCREAMING_SNAKE_CASE_			=	[
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				    14,
				    447,
				]  # the president the president the president the president the president the president the president the president the president the president
				# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
				SCREAMING_SNAKE_CASE_			=	model.generate(SCREAMING_SNAKE_CASE			,    do_sample=SCREAMING_SNAKE_CASE			)
				self.assertListEqual(output_ids[0].numpy().tolist()			,    SCREAMING_SNAKE_CASE			)






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    get_resize_output_image_size,
    normalize,
    pad,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging
from ...utils.import_utils import is_vision_available


SCREAMING_SNAKE_CASE__    :    Tuple								=					logging.get_logger(__name__)


if is_vision_available():
				import PIL



class 			a_					(    SCREAMING_SNAKE_CASE__    ):
	A						       =   ['''pixel_values''']





	def __init__(       self			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = PILImageResampling.BILINEAR			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = False			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = 1 / 255			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				None:




				"""simple docstring"""



				super().__init__(**SCREAMING_SNAKE_CASE			)

				SCREAMING_SNAKE_CASE_			=	size if size is not None else {'height': 2560, 'width': 1920}
				if isinstance(SCREAMING_SNAKE_CASE			,    (tuple, list)			):
							# The previous feature extractor size parameter was in (width, height) format
							SCREAMING_SNAKE_CASE_			=	size[::-1]
				SCREAMING_SNAKE_CASE_			=	get_size_dict(SCREAMING_SNAKE_CASE			)

				SCREAMING_SNAKE_CASE_			=	do_resize
				SCREAMING_SNAKE_CASE_			=	size
				SCREAMING_SNAKE_CASE_			=	resample
				SCREAMING_SNAKE_CASE_			=	do_thumbnail
				SCREAMING_SNAKE_CASE_			=	do_align_long_axis
				SCREAMING_SNAKE_CASE_			=	do_pad
				SCREAMING_SNAKE_CASE_			=	do_rescale
				SCREAMING_SNAKE_CASE_			=	rescale_factor
				SCREAMING_SNAKE_CASE_			=	do_normalize
				SCREAMING_SNAKE_CASE_			=	image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
				SCREAMING_SNAKE_CASE_			=	image_std if image_std is not None else IMAGENET_STANDARD_STD





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = None			)     ->				np.ndarray:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	get_image_size(SCREAMING_SNAKE_CASE			)
				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	size['height'], size['width']

				if (output_width < output_height and input_width > input_height) or (
				    output_width > output_height and input_width < input_height
				):
							SCREAMING_SNAKE_CASE_			=	np.rotaa(SCREAMING_SNAKE_CASE			,    3			)

				if data_format is not None:
							SCREAMING_SNAKE_CASE_			=	to_channel_dimension_format(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)

				return image





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = False			,    SCREAMING_SNAKE_CASE = None			,    )     ->				np.ndarray:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	size['height'], size['width']
				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	get_image_size(SCREAMING_SNAKE_CASE			)

				SCREAMING_SNAKE_CASE_			=	output_width - input_width
				SCREAMING_SNAKE_CASE_			=	output_height - input_height

				if random_padding:
							SCREAMING_SNAKE_CASE_			=	np.random.randint(low=0			,    high=delta_height + 1			)
							SCREAMING_SNAKE_CASE_			=	np.random.randint(low=0			,    high=delta_width + 1			)
				else:
							SCREAMING_SNAKE_CASE_			=	delta_height // 2
							SCREAMING_SNAKE_CASE_			=	delta_width // 2

				SCREAMING_SNAKE_CASE_			=	delta_height - pad_top
				SCREAMING_SNAKE_CASE_			=	delta_width - pad_left

				SCREAMING_SNAKE_CASE_			=	((pad_top, pad_bottom), (pad_left, pad_right))
				return pad(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    data_format=SCREAMING_SNAKE_CASE			)





	def 	A_(       self			,    *SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)     ->				Any:




				"""simple docstring"""



				logger.info('pad is deprecated and will be removed in version 4.27. Please use pad_image instead.'			)
				return self.pad_image(*SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				np.ndarray:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	get_image_size(SCREAMING_SNAKE_CASE			)
				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	size['height'], size['width']

				# We always resize to the smallest of either the input or output size.
				SCREAMING_SNAKE_CASE_			=	min(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)
				SCREAMING_SNAKE_CASE_			=	min(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)

				if height == input_height and width == input_width:
							return image

				if input_height > input_width:
							SCREAMING_SNAKE_CASE_			=	int(input_width * height / input_height			)
				elif input_width > input_height:
							SCREAMING_SNAKE_CASE_			=	int(input_height * width / input_width			)

				return resize(
				    SCREAMING_SNAKE_CASE			,    size=(height, width)			,    resample=SCREAMING_SNAKE_CASE			,    reducing_gap=2.0			,    data_format=SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				np.ndarray:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	get_size_dict(SCREAMING_SNAKE_CASE			)
				SCREAMING_SNAKE_CASE_			=	min(size['height']			,    size['width']			)
				SCREAMING_SNAKE_CASE_			=	get_resize_output_image_size(SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			,    default_to_square=SCREAMING_SNAKE_CASE			)
				SCREAMING_SNAKE_CASE_			=	resize(SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			,    resample=SCREAMING_SNAKE_CASE			,    data_format=SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)
				return resized_image





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				Any:




				"""simple docstring"""



				return rescale(SCREAMING_SNAKE_CASE			,    scale=SCREAMING_SNAKE_CASE			,    data_format=SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				np.ndarray:




				"""simple docstring"""



				return normalize(SCREAMING_SNAKE_CASE			,    mean=SCREAMING_SNAKE_CASE			,    std=SCREAMING_SNAKE_CASE			,    data_format=SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)





	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = False			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = ChannelDimension.FIRST			,    **SCREAMING_SNAKE_CASE			,    )     ->				PIL.Image.Image:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			=	do_resize if do_resize is not None else self.do_resize
				SCREAMING_SNAKE_CASE_			=	size if size is not None else self.size
				if isinstance(SCREAMING_SNAKE_CASE			,    (tuple, list)			):
							# Previous feature extractor had size in (width, height) format
							SCREAMING_SNAKE_CASE_			=	size[::-1]
				SCREAMING_SNAKE_CASE_			=	get_size_dict(SCREAMING_SNAKE_CASE			)
				SCREAMING_SNAKE_CASE_			=	resample if resample is not None else self.resample
				SCREAMING_SNAKE_CASE_			=	do_thumbnail if do_thumbnail is not None else self.do_thumbnail
				SCREAMING_SNAKE_CASE_			=	do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
				SCREAMING_SNAKE_CASE_			=	do_pad if do_pad is not None else self.do_pad
				SCREAMING_SNAKE_CASE_			=	do_rescale if do_rescale is not None else self.do_rescale
				SCREAMING_SNAKE_CASE_			=	rescale_factor if rescale_factor is not None else self.rescale_factor
				SCREAMING_SNAKE_CASE_			=	do_normalize if do_normalize is not None else self.do_normalize
				SCREAMING_SNAKE_CASE_			=	image_mean if image_mean is not None else self.image_mean
				SCREAMING_SNAKE_CASE_			=	image_std if image_std is not None else self.image_std

				SCREAMING_SNAKE_CASE_			=	make_list_of_images(SCREAMING_SNAKE_CASE			)

				if not valid_images(SCREAMING_SNAKE_CASE			):
							raise ValueError(
							    'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
							    'torch.Tensor, tf.Tensor or jax.ndarray.'			)

				if do_resize and size is None:
							raise ValueError('Size must be specified if do_resize is True.'			)

				if do_rescale and rescale_factor is None:
							raise ValueError('Rescale factor must be specified if do_rescale is True.'			)

				if do_pad and size is None:
							raise ValueError('Size must be specified if do_pad is True.'			)

				if do_normalize and (image_mean is None or image_std is None):
							raise ValueError('Image mean and std must be specified if do_normalize is True.'			)

				# All transformations expect numpy arrays.
				SCREAMING_SNAKE_CASE_			=	[to_numpy_array(SCREAMING_SNAKE_CASE			) for image in images]

				if do_align_long_axis:
							SCREAMING_SNAKE_CASE_			=	[self.align_long_axis(SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			) for image in images]

				if do_resize:
							SCREAMING_SNAKE_CASE_			=	[self.resize(image=SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			,    resample=SCREAMING_SNAKE_CASE			) for image in images]

				if do_thumbnail:
							SCREAMING_SNAKE_CASE_			=	[self.thumbnail(image=SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			) for image in images]

				if do_pad:
							SCREAMING_SNAKE_CASE_			=	[self.pad_image(image=SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			,    random_padding=SCREAMING_SNAKE_CASE			) for image in images]

				if do_rescale:
							SCREAMING_SNAKE_CASE_			=	[self.rescale(image=SCREAMING_SNAKE_CASE			,    scale=SCREAMING_SNAKE_CASE			) for image in images]

				if do_normalize:
							SCREAMING_SNAKE_CASE_			=	[self.normalize(image=SCREAMING_SNAKE_CASE			,    mean=SCREAMING_SNAKE_CASE			,    std=SCREAMING_SNAKE_CASE			) for image in images]

				SCREAMING_SNAKE_CASE_			=	[to_channel_dimension_format(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			) for image in images]

				SCREAMING_SNAKE_CASE_			=	{'pixel_values': images}
				return BatchFeature(data=SCREAMING_SNAKE_CASE			,    tensor_type=SCREAMING_SNAKE_CASE			)
