




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	,				lowerCamelCase	,				lowerCamelCase=13	,				lowerCamelCase=32	,				lowerCamelCase=2	,				lowerCamelCase=3	,				lowerCamelCase=16	,				lowerCamelCase=[1, 2, 1]	,				lowerCamelCase=[2, 2, 4]	,				lowerCamelCase=2	,				lowerCamelCase=2.0	,				lowerCamelCase=True	,				lowerCamelCase=0.0	,				lowerCamelCase=0.0	,				lowerCamelCase=0.1	,				lowerCamelCase="gelu"	,				lowerCamelCase=False	,				lowerCamelCase=True	,				lowerCamelCase=0.02	,				lowerCamelCase=1E-5	,				lowerCamelCase=True	,				lowerCamelCase=None	,				lowerCamelCase=True	,				lowerCamelCase=10	,				lowerCamelCase=8	,				) ->      Optional[int]:





								"""simple docstring"""


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

	def    __a     (					self    ) ->      str:





								"""simple docstring"""


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

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

								lowercase__        =							self.get_config()

								return config, pixel_values, labels

	def    __a     (					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    __a     (					self	,				lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase    ) ->      List[str]:





								"""simple docstring"""


								lowercase__        =							DonutSwinModel(config=lowerCamelCase    )
								model.to(lowerCamelCase    )
								model.eval()
								lowercase__        =							model(lowerCamelCase    )

								lowercase__        =							((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
								lowercase__        =							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    __a     (					self    ) ->      Optional[int]:





								"""simple docstring"""


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







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



	"""simple docstring"""






	a     : Optional[Any]	  =					(DonutSwinModel,) if is_torch_available() else ()
	a     : List[str]	  =					{'feature-extraction': DonutSwinModel} if is_torch_available() else {}
	a     : Dict	  =					True

	a     : List[str]	  =					False
	a     : int	  =					False
	a     : Any	  =					False

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





								"""simple docstring"""


								lowercase__        =							DonutSwinModelTester(self    )
								lowercase__        =							ConfigTester(self	,				config_class=lowerCamelCase	,				embed_dim=37    )

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





								"""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    __a     (					self    ) ->      str:





								"""simple docstring"""


								return

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





								"""simple docstring"""


								lowercase__        =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCamelCase    )

	def    __a     (					self    ) ->      Any:





								"""simple docstring"""


								pass

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





								"""simple docstring"""


								lowercase__        =							self.model_tester.prepare_config_and_inputs_for_common()

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

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





								"""simple docstring"""


								lowercase__        =							self.model_tester.prepare_config_and_inputs_for_common()

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

															lowercase__        =							["""pixel_values"""]
															self.assertListEqual(arg_names[:1]	,				lowerCamelCase    )

	def    __a     (					self    ) ->      str:





								"""simple docstring"""


								lowercase__        =							self.model_tester.prepare_config_and_inputs_for_common()
								lowercase__        =							True

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

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

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

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

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

															lowercase__        =							outputs.attentions

															self.assertEqual(len(lowerCamelCase    )	,				lowerCamelCase    )

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

	def    __a     (					self	,				lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase    ) ->      str:





								"""simple docstring"""


								lowercase__        =							model_class(lowerCamelCase    )
								model.to(lowerCamelCase    )
								model.eval()

								with torch.no_grad():
															lowercase__        =							model(**self._prepare_for_class(lowerCamelCase	,				lowerCamelCase    )    )

								lowercase__        =							outputs.hidden_states

								lowercase__        =							getattr(
								    self.model_tester	,				"expected_num_hidden_layers"	,				len(self.model_tester.depths    ) + 1    )
								self.assertEqual(len(lowerCamelCase    )	,				lowerCamelCase    )

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

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

								lowercase__        =							outputs.reshaped_hidden_states
								self.assertEqual(len(lowerCamelCase    )	,				lowerCamelCase    )

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

	def    __a     (					self    ) ->      List[str]:





								"""simple docstring"""


								lowercase__        =							self.model_tester.prepare_config_and_inputs_for_common()

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

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

															self.check_hidden_states_output(lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase    )

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





								"""simple docstring"""


								lowercase__        =							self.model_tester.prepare_config_and_inputs_for_common()
								lowercase__        =							3

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

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

								for model_class in self.all_model_classes:
															lowercase__        =							True
															self.check_hidden_states_output(lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase	,				(padded_height, padded_width)    )

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

	@slow
	def    __a     (					self    ) ->      Union[str, Any]:





								"""simple docstring"""


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







	def    __a     (					self    ) ->      Tuple:





								"""simple docstring"""


								lowercase__        =							self.model_tester.prepare_config_and_inputs_for_common()

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





def  snake_case_					(		)      ->			int:

							for a in range(3_00    ):
														for b in range(a + 1    ,4_00    ):
																					for c in range(b + 1    ,5_00    ):
																												if (a + b + c) == 10_00 and (a**2) + (b**2) == (c**2):
																																			return a * b * c

							return -1
def  snake_case_					(		)      ->			int:

							for a in range(3_00    ):
														for b in range(4_00    ):
																					lowercase__  :	Dict        =							10_00 - a - b
																					if a < b < c and (a**2) + (b**2) == (c**2):
																												return a * b * c

							return -1
def  snake_case_					(		)      ->			None:
							import timeit

							print(
							    timeit.timeit("solution()"    ,setup="from __main__ import solution"    ,number=10_00    )    )
							print(
							    timeit.timeit(
							        "solution_fast()"    ,setup="from __main__ import solution_fast"    ,number=10_00    )    )


if __name__ == "__main__":
						print(f'{solution() = }')