



import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    XLMForMultipleChoice,
							    XLMForQuestionAnswering,
							    XLMForQuestionAnsweringSimple,
							    XLMForSequenceClassification,
							    XLMForTokenClassification,
							    XLMModel,
							    XLMWithLMHeadModel,
							)
							from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST
class 				_snake_case			:




				def __init__(						self					:						Any,					__lowercase					:						Union[str, Any],					__lowercase					:						List[Any]=13,					__lowercase					:						Tuple=7,					__lowercase					:						List[Any]=True,					__lowercase					:						Any=True,					__lowercase					:						str=True,					__lowercase					:						str=True,					__lowercase					:						Union[str, Any]=True,					__lowercase					:						List[Any]=False,					__lowercase					:						List[Any]=False,					__lowercase					:						List[str]=False,					__lowercase					:						Optional[Any]=2,					__lowercase					:						Any=99,					__lowercase					:						Optional[Any]=0,					__lowercase					:						Any=32,					__lowercase					:						List[Any]=5,					__lowercase					:						List[str]=4,					__lowercase					:						Tuple=0.1,					__lowercase					:						int=0.1,					__lowercase					:						str=512,					__lowercase					:						List[Any]=2,					__lowercase					:						List[Any]=0.02,					__lowercase					:						List[Any]=2,					__lowercase					:						Any=4,					__lowercase					:						str="last",					__lowercase					:						Optional[int]=True,					__lowercase					:						Any=None,					__lowercase					:						Tuple=0,					):
							lowercase__					  =				parent
							lowercase__					  =				batch_size
							lowercase__					  =				seq_length
							lowercase__					  =				is_training
							lowercase__					  =				use_input_lengths
							lowercase__					  =				use_token_type_ids
							lowercase__					  =				use_labels
							lowercase__					  =				gelu_activation
							lowercase__					  =				sinusoidal_embeddings
							lowercase__					  =				causal
							lowercase__					  =				asm
							lowercase__					  =				n_langs
							lowercase__					  =				vocab_size
							lowercase__					  =				n_special
							lowercase__					  =				hidden_size
							lowercase__					  =				num_hidden_layers
							lowercase__					  =				num_attention_heads
							lowercase__					  =				hidden_dropout_prob
							lowercase__					  =				attention_probs_dropout_prob
							lowercase__					  =				max_position_embeddings
							lowercase__					  =				type_sequence_label_size
							lowercase__					  =				initializer_range
							lowercase__					  =				num_labels
							lowercase__					  =				num_choices
							lowercase__					  =				summary_type
							lowercase__					  =				use_proj
							lowercase__					  =				scope
							lowercase__					  =				bos_token_id




				def 							A__      (						self					:						int						):
							lowercase__					  =				ids_tensor([self.batch_size, self.seq_length],					self.vocab_size						)
							lowercase__					  =				random_attention_mask([self.batch_size, self.seq_length]						)

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

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

							lowercase__					  =				None
							lowercase__					  =				None
							lowercase__					  =				None
							if self.use_labels:
										lowercase__					  =				ids_tensor([self.batch_size],					self.type_sequence_label_size						)
										lowercase__					  =				ids_tensor([self.batch_size, self.seq_length],					self.num_labels						)
										lowercase__					  =				ids_tensor([self.batch_size],					2						).float()
										lowercase__					  =				ids_tensor([self.batch_size],					self.num_choices						)

							lowercase__					  =				self.get_config()

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




				def 							A__      (						self					:						int						):
							return 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,					num_labels=self.num_labels,					bos_token_id=self.bos_token_id,					)




				def 							A__      (						self					:						List[str],					__lowercase					:						Optional[int],					__lowercase					:						int,					__lowercase					:						str,					__lowercase					:						Union[str, Any],					__lowercase					:						List[str],					__lowercase					:						str,					__lowercase					:						Tuple,					__lowercase					:						Dict,					__lowercase					:						int,					):
							lowercase__					  =				XLMModel(config=__lowercase						)
							model.to(__lowercase						)
							model.eval()
							lowercase__					  =				model(__lowercase,					lengths=__lowercase,					langs=__lowercase						)
							lowercase__					  =				model(__lowercase,					langs=__lowercase						)
							lowercase__					  =				model(__lowercase						)
							self.parent.assertEqual(result.last_hidden_state.shape,					(self.batch_size, self.seq_length, self.hidden_size)						)




				def 							A__      (						self					:						Tuple,					__lowercase					:						Dict,					__lowercase					:						Optional[int],					__lowercase					:						Tuple,					__lowercase					:						List[Any],					__lowercase					:						List[Any],					__lowercase					:						Any,					__lowercase					:						Dict,					__lowercase					:						Optional[Any],					__lowercase					:						Dict,					):
							lowercase__					  =				XLMWithLMHeadModel(__lowercase						)
							model.to(__lowercase						)
							model.eval()

							lowercase__					  =				model(__lowercase,					token_type_ids=__lowercase,					labels=__lowercase						)
							self.parent.assertEqual(result.loss.shape,					()						)
							self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.seq_length, self.vocab_size)						)




				def 							A__      (						self					:						Optional[Any],					__lowercase					:						Tuple,					__lowercase					:						List[str],					__lowercase					:						str,					__lowercase					:						List[str],					__lowercase					:						Tuple,					__lowercase					:						List[str],					__lowercase					:						Any,					__lowercase					:						Union[str, Any],					__lowercase					:						int,					):
							lowercase__					  =				XLMForQuestionAnsweringSimple(__lowercase						)
							model.to(__lowercase						)
							model.eval()

							lowercase__					  =				model(__lowercase						)

							lowercase__					  =				model(__lowercase,					start_positions=__lowercase,					end_positions=__lowercase						)
							lowercase__					  =				outputs
							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					:						Optional[int],					__lowercase					:						str,					__lowercase					:						Any,					__lowercase					:						Union[str, Any],					__lowercase					:						Tuple,					__lowercase					:						str,					__lowercase					:						Any,					__lowercase					:						Dict,					__lowercase					:						Union[str, Any],					__lowercase					:						Any,					):
							lowercase__					  =				XLMForQuestionAnswering(__lowercase						)
							model.to(__lowercase						)
							model.eval()

							lowercase__					  =				model(__lowercase						)

							lowercase__					  =				model(
							    __lowercase,					start_positions=__lowercase,					end_positions=__lowercase,					cls_index=__lowercase,					is_impossible=__lowercase,					p_mask=__lowercase,					)

							lowercase__					  =				model(
							    __lowercase,					start_positions=__lowercase,					end_positions=__lowercase,					cls_index=__lowercase,					is_impossible=__lowercase,					)

							((lowercase__)  ,       )					  =				result_with_labels.to_tuple()

							lowercase__					  =				model(__lowercase,					start_positions=__lowercase,					end_positions=__lowercase						)

							((lowercase__)  ,       )					  =				result_with_labels.to_tuple()

							self.parent.assertEqual(result_with_labels.loss.shape,					()						)
							self.parent.assertEqual(result.start_top_log_probs.shape,					(self.batch_size, model.config.start_n_top)						)
							self.parent.assertEqual(result.start_top_index.shape,					(self.batch_size, model.config.start_n_top)						)
							self.parent.assertEqual(
							    result.end_top_log_probs.shape,					(self.batch_size, model.config.start_n_top * model.config.end_n_top)						)
							self.parent.assertEqual(
							    result.end_top_index.shape,					(self.batch_size, model.config.start_n_top * model.config.end_n_top)						)
							self.parent.assertEqual(result.cls_logits.shape,					(self.batch_size,)						)




				def 							A__      (						self					:						Optional[int],					__lowercase					:						int,					__lowercase					:						Optional[Any],					__lowercase					:						Tuple,					__lowercase					:						List[Any],					__lowercase					:						Tuple,					__lowercase					:						Dict,					__lowercase					:						Dict,					__lowercase					:						Optional[int],					__lowercase					:						Any,					):
							lowercase__					  =				XLMForSequenceClassification(__lowercase						)
							model.to(__lowercase						)
							model.eval()

							lowercase__					  =				model(__lowercase						)
							lowercase__					  =				model(__lowercase,					labels=__lowercase						)
							self.parent.assertEqual(result.loss.shape,					()						)
							self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.type_sequence_label_size)						)




				def 							A__      (						self					:						Optional[int],					__lowercase					:						Tuple,					__lowercase					:						Dict,					__lowercase					:						Tuple,					__lowercase					:						Optional[Any],					__lowercase					:						Union[str, Any],					__lowercase					:						int,					__lowercase					:						Optional[Any],					__lowercase					:						int,					__lowercase					:						Optional[int],					):
							lowercase__					  =				self.num_labels
							lowercase__					  =				XLMForTokenClassification(__lowercase						)
							model.to(__lowercase						)
							model.eval()

							lowercase__					  =				model(__lowercase,					attention_mask=__lowercase,					labels=__lowercase						)
							self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.seq_length, self.num_labels)						)




				def 							A__      (						self					:						List[Any],					__lowercase					:						Optional[Any],					__lowercase					:						List[Any],					__lowercase					:						int,					__lowercase					:						List[Any],					__lowercase					:						List[str],					__lowercase					:						Dict,					__lowercase					:						Union[str, Any],					__lowercase					:						int,					__lowercase					:						Dict,					):
							lowercase__					  =				self.num_choices
							lowercase__					  =				XLMForMultipleChoice(config=__lowercase						)
							model.to(__lowercase						)
							model.eval()
							lowercase__					  =				input_ids.unsqueeze(1						).expand(-1,					self.num_choices,					-1						).contiguous()
							lowercase__					  =				token_type_ids.unsqueeze(1						).expand(-1,					self.num_choices,					-1						).contiguous()
							lowercase__					  =				input_mask.unsqueeze(1						).expand(-1,					self.num_choices,					-1						).contiguous()
							lowercase__					  =				model(
							    __lowercase,					attention_mask=__lowercase,					token_type_ids=__lowercase,					labels=__lowercase,					)
							self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.num_choices)						)




				def 							A__      (						self					:						Optional[int]						):
							lowercase__					  =				self.prepare_config_and_inputs()
							(
							    (
							    lowercase__
							)  ,       (
							    lowercase__
							)  ,       (
							    lowercase__
							)  ,       (
							    lowercase__
							)  ,       (
							    lowercase__
							)  ,       (
							    lowercase__
							)  ,       (
							    lowercase__
							)  ,       (
							    lowercase__
							)  ,       (
							    lowercase__
							)  ,       
							)					  =				config_and_inputs
							lowercase__					  =				{"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
							return config, inputs_dict
@require_torch
class 				_snake_case			(					lowercase__    ,	lowercase__    ,	lowercase__    ,	unittest.TestCase):
				UpperCamelCase__				:					Optional[int]     		=(
				    (
				        XLMModel,
				        XLMWithLMHeadModel,
				        XLMForQuestionAnswering,
				        XLMForSequenceClassification,
				        XLMForQuestionAnsweringSimple,
				        XLMForTokenClassification,
				        XLMForMultipleChoice,
				    )
				    if is_torch_available()
				    else ()
				)
				UpperCamelCase__				:					Union[str, Any]     		=(
				    (XLMWithLMHeadModel,) if is_torch_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				UpperCamelCase__				:					Union[str, Any]     		=(
				    {
				        """feature-extraction""": XLMModel,
				        """fill-mask""": XLMWithLMHeadModel,
				        """question-answering""": XLMForQuestionAnsweringSimple,
				        """text-classification""": XLMForSequenceClassification,
				        """text-generation""": XLMWithLMHeadModel,
				        """token-classification""": XLMForTokenClassification,
				        """zero-shot""": XLMForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)




				def 							A__      (						self					:						Tuple,					__lowercase					:						str,					__lowercase					:						Optional[Any],					__lowercase					:						Any,					__lowercase					:						Optional[Any],					__lowercase					:						Tuple						):
							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,					__lowercase					:						str,					__lowercase					:						Tuple,					__lowercase					:						Optional[int]=False						):
							lowercase__					  =				super()._prepare_for_class(__lowercase,					__lowercase,					return_labels=__lowercase						)

							if return_labels:
										if model_class.__name__ == "XLMForQuestionAnswering":
													lowercase__					  =				torch.zeros(
													    self.model_tester.batch_size,					dtype=torch.long,					device=__lowercase						)
													lowercase__					  =				torch.zeros(
													    self.model_tester.batch_size,					dtype=torch.long,					device=__lowercase						)

							return inputs_dict




				def 							A__      (						self					:						Any						):
							lowercase__					  =				XLMModelTester(self						)
							lowercase__					  =				ConfigTester(self,					config_class=__lowercase,					emb_dim=37						)




				def 							A__      (						self					:						Tuple						):
							self.config_tester.run_common_tests()




				def 							A__      (						self					:						Union[str, Any]						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_model(*__lowercase						)




				def 							A__      (						self					:						List[str]						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_lm_head(*__lowercase						)




				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_simple_qa(*__lowercase						)




				def 							A__      (						self					:						Any						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_qa(*__lowercase						)




				def 							A__      (						self					:						Union[str, Any]						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_sequence_classif(*__lowercase						)




				def 							A__      (						self					:						Optional[int]						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_token_classif(*__lowercase						)




				def 							A__      (						self					:						str						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_for_multiple_choice(*__lowercase						)




				def 							A__      (						self					:						Optional[int],					__lowercase					:						Optional[int],					__lowercase					:						List[str],					__lowercase					:						int,					__lowercase					:						str,					__lowercase					:						int,					__lowercase					:						Any=False,					__lowercase					:						Dict=1						):
							self.assertIsInstance(__lowercase,					__lowercase						)
							self.assertListEqual(
							    [isinstance(__lowercase,					__lowercase						) for iter_attentions in attentions],					[True] * len(__lowercase						)						)
							self.assertEqual(len(__lowercase						),					(max_length - min_length) * num_beam_groups						)

							for idx, iter_attentions in enumerate(__lowercase						):
										# adds PAD dummy token
										lowercase__					  =				min_length + idx + 1
										lowercase__					  =				min_length + idx + 1

										lowercase__					  =				(
										    batch_size * num_beam_groups,
										    config.num_attention_heads,
										    tgt_len,
										    src_len,
										)
										# check attn size
										self.assertListEqual(
										    [layer_attention.shape for layer_attention in iter_attentions],					[expected_shape] * len(__lowercase						)						)




				def 							A__      (						self					:						Optional[Any],					__lowercase					:						str,					__lowercase					:						List[str],					__lowercase					:						Optional[int],					__lowercase					:						List[str],					__lowercase					:						Tuple,					__lowercase					:						Optional[int]=False,					__lowercase					:						int=1						):
							self.assertIsInstance(__lowercase,					__lowercase						)
							self.assertListEqual(
							    [isinstance(__lowercase,					__lowercase						) for iter_hidden_states in hidden_states],					[True] * len(__lowercase						),					)
							self.assertEqual(len(__lowercase						),					(max_length - min_length) * num_beam_groups						)

							for idx, iter_hidden_states in enumerate(__lowercase						):
										# adds PAD dummy token
										lowercase__					  =				min_length + idx + 1
										lowercase__					  =				(batch_size * num_beam_groups, seq_len, config.hidden_size)
										# check hidden size
										self.assertListEqual(
										    [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states],					[expected_shape] * len(__lowercase						),					)
							pass




				@slow
				def 							A__      (						self					:						Dict						):
							for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowercase__					  =				XLMModel.from_pretrained(__lowercase						)
										self.assertIsNotNone(__lowercase						)
@require_torch
class 				_snake_case			(					unittest.TestCase):




				@slow
				def 							A__      (						self					:						List[str]						):
							lowercase__					  =				XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"						)
							model.to(__lowercase						)
							lowercase__					  =				torch.tensor([[14, 447]],					dtype=torch.long,					device=__lowercase						)  # the president
							lowercase__					  =				[
							    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
							lowercase__					  =				model.generate(__lowercase,					do_sample=__lowercase						)
							self.assertListEqual(output_ids[0].cpu().numpy().tolist(),					__lowercase						)









import unittest

import numpy as np
import requests

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, prepare_image_inputs


if is_torch_available():
							import torch

							from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
							lowercase_								=     False

if is_vision_available():
							from PIL import Image

							from transformers import PixaStructImageProcessor
class 				_snake_case			(					unittest.TestCase):




				def __init__(						self					:						List[Any],					__lowercase					:						int,					__lowercase					:						Optional[int]=7,					__lowercase					:						List[str]=3,					__lowercase					:						Tuple=18,					__lowercase					:						List[Any]=30,					__lowercase					:						Tuple=400,					__lowercase					:						Any=None,					__lowercase					:						Optional[int]=True,					__lowercase					:						List[str]=True,					__lowercase					:						Union[str, Any]=None,					):
							lowercase__					  =				size if size is not None else {"height": 20, "width": 20}
							lowercase__					  =				parent
							lowercase__					  =				batch_size
							lowercase__					  =				num_channels
							lowercase__					  =				image_size
							lowercase__					  =				min_resolution
							lowercase__					  =				max_resolution
							lowercase__					  =				size
							lowercase__					  =				do_normalize
							lowercase__					  =				do_convert_rgb
							lowercase__					  =				[512, 1024, 2048, 4096]
							lowercase__					  =				patch_size if patch_size is not None else {"height": 16, "width": 16}




				def 							A__      (						self					:						List[str]						):
							return {"do_normalize": self.do_normalize, "do_convert_rgb": self.do_convert_rgb}




				def 							A__      (						self					:						Any						):
							lowercase__					  =				"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg"
							lowercase__					  =				Image.open(requests.get(__lowercase,					stream=__lowercase						).raw						).convert("RGB"						)
							return raw_image
@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11    ,	reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""    ,	)
@require_torch
@require_vision
class 				_snake_case			(					lowercase__    ,	unittest.TestCase):
				UpperCamelCase__				:					Any     		=PixaStructImageProcessor if is_vision_available() else None




				def 							A__      (						self					:						Any						):
							lowercase__					  =				PixaStructImageProcessingTester(self						)




				@property
				def 							A__      (						self					:						Union[str, Any]						):
							return self.image_processor_tester.prepare_image_processor_dict()




				def 							A__      (						self					:						Optional[Any]						):
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							self.assertTrue(hasattr(__lowercase,					"do_normalize"						)						)
							self.assertTrue(hasattr(__lowercase,					"do_convert_rgb"						)						)




				def 							A__      (						self					:						Optional[int]						):
							lowercase__					  =				self.image_processor_tester.prepare_dummy_image()

							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							lowercase__					  =				2048

							lowercase__					  =				image_processor(__lowercase,					return_tensors="pt",					max_patches=__lowercase						)
							self.assertTrue(torch.allclose(inputs.flattened_patches.mean(),					torch.tensor(0.0606						),					atol=1e-3,					rtol=1e-3						)						)




				def 							A__      (						self					:						Union[str, Any]						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PIL images
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					Image.Image						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




				def 							A__      (						self					:						int						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PIL images
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					Image.Image						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							lowercase__					  =				True

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										with self.assertRaises(__lowercase						):
													lowercase__					  =				image_processor(
													    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches

										lowercase__					  =				"Hello"

										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase,					header_text=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase,					header_text=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




				def 							A__      (						self					:						Tuple						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random numpy tensors
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase,					numpify=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					np.ndarray						)

							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




				def 							A__      (						self					:						Any						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PyTorch tensors
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase,					torchify=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					torch.Tensor						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)
@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11    ,	reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""    ,	)
@require_torch
@require_vision
class 				_snake_case			(					lowercase__    ,	unittest.TestCase):
				UpperCamelCase__				:					Optional[int]     		=PixaStructImageProcessor if is_vision_available() else None




				def 							A__      (						self					:						Optional[int]						):
							lowercase__					  =				PixaStructImageProcessingTester(self,					num_channels=4						)
							lowercase__					  =				3




				@property
				def 							A__      (						self					:						Union[str, Any]						):
							return self.image_processor_tester.prepare_image_processor_dict()




				def 							A__      (						self					:						Dict						):
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							self.assertTrue(hasattr(__lowercase,					"do_normalize"						)						)
							self.assertTrue(hasattr(__lowercase,					"do_convert_rgb"						)						)




				def 							A__      (						self					:						Union[str, Any]						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PIL images
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					Image.Image						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * (self.image_processor_tester.num_channels - 1)
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




