




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 		UpperCAmelCase       :







						'''simple docstring'''





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






							"""simple docstring"""






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






						def 	snake_case__						(						self							:					Union[str, Any]						):






							"""simple docstring"""






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

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

							snake_case_		   =					self.get_config()

							return config, pixel_values, labels






						def 	snake_case__						(						self							:					Tuple						):






							"""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 	snake_case__						(						self							:					str	,     __lowercase							:					Tuple	,     __lowercase							:					Union[str, Any]	,     __lowercase							:					str						):






							"""simple docstring"""






							snake_case_		   =					DonutSwinModel(config=__lowercase						)
							model.to(__lowercase						)
							model.eval()
							snake_case_		   =					model(__lowercase						)

							snake_case_		   =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
							snake_case_		   =					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 	snake_case__						(						self							:					List[Any]						):






							"""simple docstring"""






							snake_case_		   =					self.prepare_config_and_inputs()
							(
							    (
							    snake_case_
							)   ,				(
							    snake_case_
							)   ,				(
							    snake_case_
							)   ,				
							)		   =					config_and_inputs
							snake_case_		   =					{"pixel_values": pixel_values}
							return config, inputs_dict







@require_torch
class 		UpperCAmelCase       (    UpperCAmelCase__	,       UpperCAmelCase__	,       unittest.TestCase      ):







						'''simple docstring'''





						lowerCAmelCase_							=       (DonutSwinModel,) if is_torch_available() else ()
						lowerCAmelCase_							=       {'''feature-extraction''': DonutSwinModel} if is_torch_available() else {}
						lowerCAmelCase_							=       True

						lowerCAmelCase_							=       False
						lowerCAmelCase_							=       False
						lowerCAmelCase_							=       False






						def 	snake_case__						(						self							:					Optional[int]						):






							"""simple docstring"""






							snake_case_		   =					DonutSwinModelTester(self						)
							snake_case_		   =					ConfigTester(self	,     config_class=__lowercase	,     embed_dim=37						)






						def 	snake_case__						(						self							:					int						):






							"""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 	snake_case__						(						self							:					Tuple						):






							"""simple docstring"""






							return






						def 	snake_case__						(						self							:					List[Any]						):






							"""simple docstring"""






							snake_case_		   =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__lowercase						)






						def 	snake_case__						(						self							:					List[str]						):






							"""simple docstring"""






							pass






						def 	snake_case__						(						self							:					Optional[int]						):






							"""simple docstring"""






							snake_case_   ,				snake_case_		   =					self.model_tester.prepare_config_and_inputs_for_common()

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






						def 	snake_case__						(						self							:					str						):






							"""simple docstring"""






							snake_case_   ,				snake_case_		   =					self.model_tester.prepare_config_and_inputs_for_common()

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

								snake_case_		   =					["pixel_values"]
								self.assertListEqual(arg_names[:1]	,     __lowercase						)






						def 	snake_case__						(						self							:					Tuple						):






							"""simple docstring"""






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

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

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

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

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

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

								snake_case_		   =					outputs.attentions

								self.assertEqual(len(__lowercase						)	,     __lowercase						)

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






						def 	snake_case__						(						self							:					Optional[Any]	,     __lowercase							:					List[str]	,     __lowercase							:					Optional[Any]	,     __lowercase							:					Tuple	,     __lowercase							:					List[Any]						):






							"""simple docstring"""






							snake_case_		   =					model_class(__lowercase						)
							model.to(__lowercase						)
							model.eval()

							with torch.no_grad():
								snake_case_		   =					model(**self._prepare_for_class(__lowercase	,     __lowercase						)						)

							snake_case_		   =					outputs.hidden_states

							snake_case_		   =					getattr(
							    self.model_tester	,     "expected_num_hidden_layers"	,     len(self.model_tester.depths						) + 1						)
							self.assertEqual(len(__lowercase						)	,     __lowercase						)

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

							snake_case_		   =					(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]	,     )

							snake_case_		   =					outputs.reshaped_hidden_states
							self.assertEqual(len(__lowercase						)	,     __lowercase						)

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






						def 	snake_case__						(						self							:					List[Any]						):






							"""simple docstring"""






							snake_case_   ,				snake_case_		   =					self.model_tester.prepare_config_and_inputs_for_common()

							snake_case_		   =					(
							    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:
								snake_case_		   =					True
								self.check_hidden_states_output(__lowercase	,     __lowercase	,     __lowercase	,     __lowercase						)

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

								self.check_hidden_states_output(__lowercase	,     __lowercase	,     __lowercase	,     __lowercase						)






						def 	snake_case__						(						self							:					int						):






							"""simple docstring"""






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

							snake_case_		   =					(
							    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)
							)
							snake_case_		   =					(
							    config.patch_size
							    if isinstance(config.patch_size	,     collections.abc.Iterable						)
							    else (config.patch_size, config.patch_size)
							)

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

							for model_class in self.all_model_classes:
								snake_case_		   =					True
								self.check_hidden_states_output(__lowercase	,     __lowercase	,     __lowercase	,     (padded_height, padded_width)						)

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






						@slow
						def 	snake_case__						(						self							:					Any						):






							"""simple docstring"""






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






						def 	snake_case__						(						self							:					Optional[int]						):






							"""simple docstring"""






							snake_case_   ,				snake_case_		   =					self.model_tester.prepare_config_and_inputs_for_common()

							snake_case_		   =					_config_zero_init(__lowercase						)
							for model_class in self.all_model_classes:
								snake_case_		   =					model_class(config=__lowercase						)
								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"	,     )






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available


lowercase__    :					List[str]					=						{
    "configuration_xlm_prophetnet": ["XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMProphetNetConfig"],
}

try:
		if not is_sentencepiece_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase__    :					Optional[Any]					=						["XLMProphetNetTokenizer"]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase__    :					List[Any]					=						[
		    "XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "XLMProphetNetDecoder",
		    "XLMProphetNetEncoder",
		    "XLMProphetNetForCausalLM",
		    "XLMProphetNetForConditionalGeneration",
		    "XLMProphetNetModel",
		    "XLMProphetNetPreTrainedModel",
		]


if TYPE_CHECKING:
		from .configuration_xlm_prophetnet import XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMProphetNetConfig

		try:
				if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_xlm_prophetnet import XLMProphetNetTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_xlm_prophetnet import (
				    XLM_PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST,
				    XLMProphetNetDecoder,
				    XLMProphetNetEncoder,
				    XLMProphetNetForCausalLM,
				    XLMProphetNetForConditionalGeneration,
				    XLMProphetNetModel,
				    XLMProphetNetPreTrainedModel,
				)

else:
		import sys

		lowercase__    :					Any					=						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
