
"""simple docstring"""




import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch
					from torch import nn

					from transformers import DonutSwinModel
					from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST
class SCREAMING_SNAKE_CASE       :






	'''simple docstring'''







	def __init__(  self :Union[str, Any]       ,    __magic_name__ :Union[str, Any]       ,    __magic_name__ :Tuple=13       ,    __magic_name__ :Union[str, Any]=32       ,    __magic_name__ :List[str]=2       ,    __magic_name__ :Union[str, Any]=3       ,    __magic_name__ :Dict=16       ,    __magic_name__ :Optional[Any]=[1, 2, 1]       ,    __magic_name__ :Optional[int]=[2, 2, 4]       ,    __magic_name__ :Tuple=2       ,    __magic_name__ :Tuple=2.0       ,    __magic_name__ :Tuple=True       ,    __magic_name__ :Optional[int]=0.0       ,    __magic_name__ :str=0.0       ,    __magic_name__ :List[Any]=0.1       ,    __magic_name__ :List[Any]="gelu"       ,    __magic_name__ :Union[str, Any]=False       ,    __magic_name__ :Dict=True       ,    __magic_name__ :Union[str, Any]=0.02       ,    __magic_name__ :Union[str, Any]=1e-5       ,    __magic_name__ :Optional[int]=True       ,    __magic_name__ :int=None       ,    __magic_name__ :str=True       ,    __magic_name__ :Dict=10       ,    __magic_name__ :Dict=8       ,    )			->   str:

			'''simple docstring'''






			a__   		=     parent
			a__   		=     batch_size
			a__   		=     image_size
			a__   		=     patch_size
			a__   		=     num_channels
			a__   		=     embed_dim
			a__   		=     depths
			a__   		=     num_heads
			a__   		=     window_size
			a__   		=     mlp_ratio
			a__   		=     qkv_bias
			a__   		=     hidden_dropout_prob
			a__   		=     attention_probs_dropout_prob
			a__   		=     drop_path_rate
			a__   		=     hidden_act
			a__   		=     use_absolute_embeddings
			a__   		=     patch_norm
			a__   		=     layer_norm_eps
			a__   		=     initializer_range
			a__   		=     is_training
			a__   		=     scope
			a__   		=     use_labels
			a__   		=     type_sequence_label_size
			a__   		=     encoder_stride


	def    _UpperCamelCase							(  self :Tuple			)			->   Tuple:

			'''simple docstring'''






			a__   		=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

			a__   		=     None
			if self.use_labels:
					a__   		=     ids_tensor([self.batch_size]       ,    self.type_sequence_label_size			)

			a__   		=     self.get_config()

			return config, pixel_values, labels


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

			'''simple docstring'''






			return DonutSwinConfig(
			    image_size=self.image_size       ,    patch_size=self.patch_size       ,    num_channels=self.num_channels       ,    embed_dim=self.embed_dim       ,    depths=self.depths       ,    num_heads=self.num_heads       ,    window_size=self.window_size       ,    mlp_ratio=self.mlp_ratio       ,    qkv_bias=self.qkv_bias       ,    hidden_dropout_prob=self.hidden_dropout_prob       ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,    drop_path_rate=self.drop_path_rate       ,    hidden_act=self.hidden_act       ,    use_absolute_embeddings=self.use_absolute_embeddings       ,    path_norm=self.patch_norm       ,    layer_norm_eps=self.layer_norm_eps       ,    initializer_range=self.initializer_range       ,    encoder_stride=self.encoder_stride       ,    )


	def    _UpperCamelCase							(  self :int       ,    __magic_name__ :Any       ,    __magic_name__ :List[Any]       ,    __magic_name__ :int			)			->   Dict:

			'''simple docstring'''






			a__   		=     DonutSwinModel(config=__magic_name__			)
			model.to(__magic_name__			)
			model.eval()
			a__   		=     model(__magic_name__			)

			a__   		=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
			a__   		=     int(config.embed_dim * 2 ** (len(config.depths			) - 1)			)

			self.parent.assertEqual(result.last_hidden_state.shape       ,    (self.batch_size, expected_seq_len, expected_dim)			)






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

			'''simple docstring'''






			a__   		=     self.prepare_config_and_inputs()
			(
			    (
			    a__
			)		,	(
			    a__
			)		,	(
			    a__
			)		,	
			)   		=     config_and_inputs
			a__   		=     {'''pixel_values''': pixel_values}
			return config, inputs_dict

@require_torch
class SCREAMING_SNAKE_CASE       (      lowerCAmelCase					,   lowerCAmelCase					,   unittest.TestCase					):






	'''simple docstring'''







	snake_case__							:		Any         =		(DonutSwinModel,) if is_torch_available() else ()
	snake_case__							:		Union[str, Any]         =		{'feature-extraction': DonutSwinModel} if is_torch_available() else {}
	snake_case__							:		Tuple         =		True

	snake_case__							:		Union[str, Any]         =		False
	snake_case__							:		Dict         =		False
	snake_case__							:		List[Any]         =		False


	def    _UpperCamelCase							(  self :Dict			)			->   List[str]:

			'''simple docstring'''






			a__   		=     DonutSwinModelTester(self			)
			a__   		=     ConfigTester(self       ,    config_class=__magic_name__       ,    embed_dim=37			)


	def    _UpperCamelCase							(  self :Any			)			->   Dict:

			'''simple docstring'''






			self.create_and_test_config_common_properties()
			self.config_tester.create_and_test_config_to_json_string()
			self.config_tester.create_and_test_config_to_json_file()
			self.config_tester.create_and_test_config_from_and_save_pretrained()
			self.config_tester.create_and_test_config_with_num_labels()
			self.config_tester.check_config_can_be_init_without_params()
			self.config_tester.check_config_arguments_init()


	def    _UpperCamelCase							(  self :Dict			)			->   Dict:

			'''simple docstring'''






			return


	def    _UpperCamelCase							(  self :Optional[int]			)			->   Any:

			'''simple docstring'''






			a__   		=     self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*__magic_name__			)


	def    _UpperCamelCase							(  self :Tuple			)			->   Any:

			'''simple docstring'''






			pass


	def    _UpperCamelCase							(  self :Dict			)			->   Optional[Any]:

			'''simple docstring'''






			a__		,	a__   		=     self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					a__   		=     model_class(__magic_name__			)
					self.assertIsInstance(model.get_input_embeddings()       ,    (nn.Module)			)
					a__   		=     model.get_output_embeddings()
					self.assertTrue(x is None or isinstance(__magic_name__       ,    nn.Linear			)			)


	def    _UpperCamelCase							(  self :List[str]			)			->   Tuple:

			'''simple docstring'''






			a__		,	a__   		=     self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					a__   		=     model_class(__magic_name__			)
					a__   		=     inspect.signature(model.forward			)
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					a__   		=     [*signature.parameters.keys()]

					a__   		=     ['''pixel_values''']
					self.assertListEqual(arg_names[:1]       ,    __magic_name__			)


	def    _UpperCamelCase							(  self :Dict			)			->   List[Any]:

			'''simple docstring'''






			a__		,	a__   		=     self.model_tester.prepare_config_and_inputs_for_common()
			a__   		=     True

			for model_class in self.all_model_classes:
					a__   		=     True
					a__   		=     False
					a__   		=     True
					a__   		=     model_class(__magic_name__			)
					model.to(__magic_name__			)
					model.eval()
					with torch.no_grad():
							a__   		=     model(**self._prepare_for_class(__magic_name__       ,    __magic_name__			)			)
					a__   		=     outputs.attentions
					a__   		=     len(self.model_tester.depths			)
					self.assertEqual(len(__magic_name__			)       ,    __magic_name__			)

					# check that output_attentions also work using config
					del inputs_dict["output_attentions"]
					a__   		=     True
					a__   		=     config.window_size**2
					a__   		=     model_class(__magic_name__			)
					model.to(__magic_name__			)
					model.eval()
					with torch.no_grad():
							a__   		=     model(**self._prepare_for_class(__magic_name__       ,    __magic_name__			)			)
					a__   		=     outputs.attentions
					self.assertEqual(len(__magic_name__			)       ,    __magic_name__			)

					self.assertListEqual(
					    list(attentions[0].shape[-3:]			)       ,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,    )
					a__   		=     len(__magic_name__			)

					# Check attention is always last and order is fine
					a__   		=     True
					a__   		=     True
					a__   		=     model_class(__magic_name__			)
					model.to(__magic_name__			)
					model.eval()
					with torch.no_grad():
							a__   		=     model(**self._prepare_for_class(__magic_name__       ,    __magic_name__			)			)

					if hasattr(self.model_tester       ,    '''num_hidden_states_types'''			):
							a__   		=     self.model_tester.num_hidden_states_types
					else:
							# also another +1 for reshaped_hidden_states
							a__   		=     2
					self.assertEqual(out_len + added_hidden_states       ,    len(__magic_name__			)			)

					a__   		=     outputs.attentions

					self.assertEqual(len(__magic_name__			)       ,    __magic_name__			)

					self.assertListEqual(
					    list(self_attentions[0].shape[-3:]			)       ,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,    )


	def    _UpperCamelCase							(  self :Optional[Any]       ,    __magic_name__ :List[str]       ,    __magic_name__ :Dict       ,    __magic_name__ :str       ,    __magic_name__ :List[str]			)			->   Any:

			'''simple docstring'''






			a__   		=     model_class(__magic_name__			)
			model.to(__magic_name__			)
			model.eval()

			with torch.no_grad():
					a__   		=     model(**self._prepare_for_class(__magic_name__       ,    __magic_name__			)			)

			a__   		=     outputs.hidden_states

			a__   		=     getattr(
			    self.model_tester       ,    '''expected_num_hidden_layers'''       ,    len(self.model_tester.depths			) + 1			)
			self.assertEqual(len(__magic_name__			)       ,    __magic_name__			)

			# DonutSwin has a different seq_length
			a__   		=     (
			    config.patch_size
			    if isinstance(config.patch_size       ,    collections.abc.Iterable			)
			    else (config.patch_size, config.patch_size)
			)

			a__   		=     (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

			self.assertListEqual(
			    list(hidden_states[0].shape[-2:]			)       ,    [num_patches, self.model_tester.embed_dim]       ,    )

			a__   		=     outputs.reshaped_hidden_states
			self.assertEqual(len(__magic_name__			)       ,    __magic_name__			)

			a__		,	a__		,	a__		,	a__   		=     reshaped_hidden_states[0].shape
			a__   		=     (
			    reshaped_hidden_states[0].view(__magic_name__       ,    __magic_name__       ,    height * width			).permute(0       ,    2       ,    1			)
			)
			self.assertListEqual(
			    list(reshaped_hidden_states.shape[-2:]			)       ,    [num_patches, self.model_tester.embed_dim]       ,    )


	def    _UpperCamelCase							(  self :int			)			->   Optional[Any]:

			'''simple docstring'''






			a__		,	a__   		=     self.model_tester.prepare_config_and_inputs_for_common()

			a__   		=     (
			    self.model_tester.image_size
			    if isinstance(self.model_tester.image_size       ,    collections.abc.Iterable			)
			    else (self.model_tester.image_size, self.model_tester.image_size)
			)

			for model_class in self.all_model_classes:
					a__   		=     True
					self.check_hidden_states_output(__magic_name__       ,    __magic_name__       ,    __magic_name__       ,    __magic_name__			)

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					a__   		=     True

					self.check_hidden_states_output(__magic_name__       ,    __magic_name__       ,    __magic_name__       ,    __magic_name__			)


	def    _UpperCamelCase							(  self :Optional[int]			)			->   Any:

			'''simple docstring'''






			a__		,	a__   		=     self.model_tester.prepare_config_and_inputs_for_common()
			a__   		=     3

			a__   		=     (
			    self.model_tester.image_size
			    if isinstance(self.model_tester.image_size       ,    collections.abc.Iterable			)
			    else (self.model_tester.image_size, self.model_tester.image_size)
			)
			a__   		=     (
			    config.patch_size
			    if isinstance(config.patch_size       ,    collections.abc.Iterable			)
			    else (config.patch_size, config.patch_size)
			)

			a__   		=     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
			a__   		=     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

			for model_class in self.all_model_classes:
					a__   		=     True
					self.check_hidden_states_output(__magic_name__       ,    __magic_name__       ,    __magic_name__       ,    (padded_height, padded_width)			)

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					a__   		=     True
					self.check_hidden_states_output(__magic_name__       ,    __magic_name__       ,    __magic_name__       ,    (padded_height, padded_width)			)


	@slow
	def    _UpperCamelCase							(  self :Optional[Any]			)			->   Optional[int]:

			'''simple docstring'''






			for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					a__   		=     DonutSwinModel.from_pretrained(__magic_name__			)
					self.assertIsNotNone(__magic_name__			)






	def    _UpperCamelCase							(  self :List[Any]			)			->   Optional[Any]:

			'''simple docstring'''






			a__		,	a__   		=     self.model_tester.prepare_config_and_inputs_for_common()

			a__   		=     _config_zero_init(__magic_name__			)
			for model_class in self.all_model_classes:
					a__   		=     model_class(config=__magic_name__			)
					for name, param in model.named_parameters():
							if "embeddings" not in name and param.requires_grad:
									self.assertIn(
									    ((param.data.mean() * 1e9).round() / 1e9).item()       ,    [0.0, 1.0]       ,    msg=F"Parameter {name} of model {model_class} seems not properly initialized"       ,    )






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


if is_torch_available():
					import torch

if is_vision_available():
					from PIL import Image

					from transformers import MobileNetVaImageProcessor
class SCREAMING_SNAKE_CASE       (      unittest.TestCase					):






	'''simple docstring'''







	def __init__(  self :Tuple       ,    __magic_name__ :str       ,    __magic_name__ :Optional[Any]=7       ,    __magic_name__ :int=3       ,    __magic_name__ :Union[str, Any]=18       ,    __magic_name__ :Union[str, Any]=30       ,    __magic_name__ :str=400       ,    __magic_name__ :str=True       ,    __magic_name__ :Any=None       ,    __magic_name__ :Tuple=True       ,    __magic_name__ :List[str]=None       ,    )			->   Optional[int]:

			'''simple docstring'''






			a__   		=     size if size is not None else {'''shortest_edge''': 20}
			a__   		=     crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
			a__   		=     parent
			a__   		=     batch_size
			a__   		=     num_channels
			a__   		=     image_size
			a__   		=     min_resolution
			a__   		=     max_resolution
			a__   		=     do_resize
			a__   		=     size
			a__   		=     do_center_crop
			a__   		=     crop_size






	def    _UpperCamelCase							(  self :Tuple			)			->   Any:

			'''simple docstring'''






			return {
			    "do_resize": self.do_resize,
			    "size": self.size,
			    "do_center_crop": self.do_center_crop,
			    "crop_size": self.crop_size,
			}

@require_torch
@require_vision
class SCREAMING_SNAKE_CASE       (      lowerCAmelCase					,   unittest.TestCase					):






	'''simple docstring'''







	snake_case__							:		str         =		MobileNetVaImageProcessor if is_vision_available() else None


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

			'''simple docstring'''






			a__   		=     MobileNetVaImageProcessingTester(self			)


	@property
	def    _UpperCamelCase							(  self :List[str]			)			->   Optional[Any]:

			'''simple docstring'''






			return self.image_processor_tester.prepare_image_processor_dict()


	def    _UpperCamelCase							(  self :Tuple			)			->   Tuple:

			'''simple docstring'''






			a__   		=     self.image_processing_class(**self.image_processor_dict			)
			self.assertTrue(hasattr(__magic_name__       ,    '''do_resize'''			)			)
			self.assertTrue(hasattr(__magic_name__       ,    '''size'''			)			)
			self.assertTrue(hasattr(__magic_name__       ,    '''do_center_crop'''			)			)
			self.assertTrue(hasattr(__magic_name__       ,    '''center_crop'''			)			)


	def    _UpperCamelCase							(  self :List[Any]			)			->   int:

			'''simple docstring'''






			a__   		=     self.image_processing_class.from_dict(self.image_processor_dict			)
			self.assertEqual(image_processor.size       ,    {'''shortest_edge''': 20}			)
			self.assertEqual(image_processor.crop_size       ,    {'''height''': 18, '''width''': 18}			)

			a__   		=     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    _UpperCamelCase							(  self :Optional[int]			)			->   Any:

			'''simple docstring'''






			pass


	def    _UpperCamelCase							(  self :Dict			)			->   Tuple:

			'''simple docstring'''






			a__   		=     self.image_processing_class(**self.image_processor_dict			)
			# create random PIL images
			a__   		=     prepare_image_inputs(self.image_processor_tester       ,    equal_resolution=__magic_name__			)
			for image in image_inputs:
					self.assertIsInstance(__magic_name__       ,    Image.Image			)

			# Test not batched input
			a__   		=     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
			a__   		=     image_processing(__magic_name__       ,    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    _UpperCamelCase							(  self :Optional[Any]			)			->   Union[str, Any]:

			'''simple docstring'''






			a__   		=     self.image_processing_class(**self.image_processor_dict			)
			# create random numpy tensors
			a__   		=     prepare_image_inputs(self.image_processor_tester       ,    equal_resolution=__magic_name__       ,    numpify=__magic_name__			)
			for image in image_inputs:
					self.assertIsInstance(__magic_name__       ,    np.ndarray			)

			# Test not batched input
			a__   		=     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
			a__   		=     image_processing(__magic_name__       ,    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    _UpperCamelCase							(  self :List[Any]			)			->   str:

			'''simple docstring'''






			a__   		=     self.image_processing_class(**self.image_processor_dict			)
			# create random PyTorch tensors
			a__   		=     prepare_image_inputs(self.image_processor_tester       ,    equal_resolution=__magic_name__       ,    torchify=__magic_name__			)
			for image in image_inputs:
					self.assertIsInstance(__magic_name__       ,    torch.Tensor			)

			# Test not batched input
			a__   		=     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
			a__   		=     image_processing(__magic_name__       ,    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'''],
			    )       ,    )




