




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				:

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







						'''simple docstring'''




						lowerCamelCase_				:						Any				  =				parent
						lowerCamelCase_				:						Any				  =				batch_size
						lowerCamelCase_				:						int				  =				image_size
						lowerCamelCase_				:						Tuple				  =				patch_size
						lowerCamelCase_				:						Dict				  =				num_channels
						lowerCamelCase_				:						str				  =				embed_dim
						lowerCamelCase_				:						List[str]				  =				depths
						lowerCamelCase_				:						Optional[Any]				  =				num_heads
						lowerCamelCase_				:						Tuple				  =				window_size
						lowerCamelCase_				:						Dict				  =				mlp_ratio
						lowerCamelCase_				:						Optional[Any]				  =				qkv_bias
						lowerCamelCase_				:						List[Any]				  =				hidden_dropout_prob
						lowerCamelCase_				:						str				  =				attention_probs_dropout_prob
						lowerCamelCase_				:						Optional[int]				  =				drop_path_rate
						lowerCamelCase_				:						Tuple				  =				hidden_act
						lowerCamelCase_				:						Optional[int]				  =				use_absolute_embeddings
						lowerCamelCase_				:						Optional[Any]				  =				patch_norm
						lowerCamelCase_				:						str				  =				layer_norm_eps
						lowerCamelCase_				:						Dict				  =				initializer_range
						lowerCamelCase_				:						str				  =				is_training
						lowerCamelCase_				:						Any				  =				scope
						lowerCamelCase_				:						int				  =				use_labels
						lowerCamelCase_				:						Tuple				  =				type_sequence_label_size
						lowerCamelCase_				:						Tuple				  =				encoder_stride

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Dict				  =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

						lowerCamelCase_				:						Any				  =				None
						if self.use_labels:
							lowerCamelCase_				:						Union[str, Any]				  =				ids_tensor([self.batch_size]					,			self.type_sequence_label_size   )

						lowerCamelCase_				:						Optional[Any]				  =				self.get_config()

						return config, pixel_values, labels

					def       lowercase_				(							self   ):







						'''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       lowercase_				(							self					,			__lowercase					,			__lowercase					,			__lowercase   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[str]				  =				DonutSwinModel(config=__lowercase   )
						model.to(__lowercase   )
						model.eval()
						lowerCamelCase_				:						Any				  =				model(__lowercase   )

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







						'''simple docstring'''




						lowerCamelCase_				:						List[Any]				  =				self.prepare_config_and_inputs()
						(
						    (
						    lowerCamelCase_
						)  ,     (
						    lowerCamelCase_
						)  ,     (
						    lowerCamelCase_
						)  ,     
						)				:						Union[str, Any]				  =				config_and_inputs
						lowerCamelCase_				:						Any				  =				{'pixel_values': pixel_values}
						return config, inputs_dict


@require_torch
class 							__SCREAMING_SNAKE_CASE				(						lowerCamelCase  ,	lowerCamelCase  ,	unittest.TestCase    ):
					_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       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						int				  =				DonutSwinModelTester(self   )
						lowerCamelCase_				:						Optional[int]				  =				ConfigTester(self					,			config_class=__lowercase					,			embed_dim=37   )

					def       lowercase_				(							self   ):







						'''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       lowercase_				(							self   ):







						'''simple docstring'''




						return

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Optional[int]				  =				self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__lowercase   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						pass

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_  ,     lowerCamelCase_				:						Dict				  =				self.model_tester.prepare_config_and_inputs_for_common()

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

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_  ,     lowerCamelCase_				:						Optional[Any]				  =				self.model_tester.prepare_config_and_inputs_for_common()

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

							lowerCamelCase_				:						str				  =				['pixel_values']
							self.assertListEqual(arg_names[:1]					,			__lowercase   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_  ,     lowerCamelCase_				:						Dict				  =				self.model_tester.prepare_config_and_inputs_for_common()
						lowerCamelCase_				:						Dict				  =				True

						for model_class in self.all_model_classes:
							lowerCamelCase_				:						Optional[Any]				  =				True
							lowerCamelCase_				:						int				  =				False
							lowerCamelCase_				:						Any				  =				True
							lowerCamelCase_				:						Union[str, Any]				  =				model_class(__lowercase   )
							model.to(__lowercase   )
							model.eval()
							with torch.no_grad():
								lowerCamelCase_				:						int				  =				model(**self._prepare_for_class(__lowercase					,			__lowercase   )   )
							lowerCamelCase_				:						Union[str, Any]				  =				outputs.attentions
							lowerCamelCase_				:						List[str]				  =				len(self.model_tester.depths   )
							self.assertEqual(len(__lowercase   )					,			__lowercase   )

							# check that output_attentions also work using config
							del inputs_dict["output_attentions"]
							lowerCamelCase_				:						Any				  =				True
							lowerCamelCase_				:						Union[str, Any]				  =				config.window_size**2
							lowerCamelCase_				:						Dict				  =				model_class(__lowercase   )
							model.to(__lowercase   )
							model.eval()
							with torch.no_grad():
								lowerCamelCase_				:						Optional[int]				  =				model(**self._prepare_for_class(__lowercase					,			__lowercase   )   )
							lowerCamelCase_				:						Optional[int]				  =				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]					,			)
							lowerCamelCase_				:						Optional[Any]				  =				len(__lowercase   )

							# Check attention is always last and order is fine
							lowerCamelCase_				:						List[str]				  =				True
							lowerCamelCase_				:						Tuple				  =				True
							lowerCamelCase_				:						str				  =				model_class(__lowercase   )
							model.to(__lowercase   )
							model.eval()
							with torch.no_grad():
								lowerCamelCase_				:						Optional[Any]				  =				model(**self._prepare_for_class(__lowercase					,			__lowercase   )   )

							if hasattr(self.model_tester					,			'num_hidden_states_types'   ):
								lowerCamelCase_				:						Optional[Any]				  =				self.model_tester.num_hidden_states_types
							else:
								# also another +1 for reshaped_hidden_states
								lowerCamelCase_				:						str				  =				2
							self.assertEqual(out_len + added_hidden_states					,			len(__lowercase   )   )

							lowerCamelCase_				:						Optional[int]				  =				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       lowercase_				(							self					,			__lowercase					,			__lowercase					,			__lowercase					,			__lowercase   ):







						'''simple docstring'''




						lowerCamelCase_				:						Union[str, Any]				  =				model_class(__lowercase   )
						model.to(__lowercase   )
						model.eval()

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

						lowerCamelCase_				:						Tuple				  =				outputs.hidden_states

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

						lowerCamelCase_				:						Dict				  =				(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]					,			)

						lowerCamelCase_				:						Any				  =				outputs.reshaped_hidden_states
						self.assertEqual(len(__lowercase   )					,			__lowercase   )

						lowerCamelCase_  ,     lowerCamelCase_  ,     lowerCamelCase_  ,     lowerCamelCase_				:						List[str]				  =				reshaped_hidden_states[0].shape
						lowerCamelCase_				:						str				  =				(
						    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       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_  ,     lowerCamelCase_				:						Union[str, Any]				  =				self.model_tester.prepare_config_and_inputs_for_common()

						lowerCamelCase_				:						Optional[int]				  =				(
						    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:
							lowerCamelCase_				:						Any				  =				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"]
							lowerCamelCase_				:						Optional[Any]				  =				True

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

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_  ,     lowerCamelCase_				:						List[str]				  =				self.model_tester.prepare_config_and_inputs_for_common()
						lowerCamelCase_				:						Optional[int]				  =				3

						lowerCamelCase_				:						Tuple				  =				(
						    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)
						)
						lowerCamelCase_				:						Optional[Any]				  =				(
						    config.patch_size
						    if isinstance(config.patch_size					,			collections.abc.Iterable   )
						    else (config.patch_size, config.patch_size)
						)

						lowerCamelCase_				:						List[Any]				  =				image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
						lowerCamelCase_				:						Dict				  =				image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

						for model_class in self.all_model_classes:
							lowerCamelCase_				:						Optional[int]				  =				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"]
							lowerCamelCase_				:						Any				  =				True
							self.check_hidden_states_output(__lowercase					,			__lowercase					,			__lowercase					,			(padded_height, padded_width)   )

					@slow
					def       lowercase_				(							self   ):







						'''simple docstring'''




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





					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_  ,     lowerCamelCase_				:						Union[str, Any]				  =				self.model_tester.prepare_config_and_inputs_for_common()

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


def  A			(   lowercase					)  ->    str:
		'''simple docstring'''

		if not isinstance(lowercase       ,			lowercase					):
				UpperCamelCase            =	(
				    'operation can not be conducted on a object of type '
				    f'''{type(lowercase					).__name__}'''
				)
				raise TypeError(lowercase					)
		UpperCamelCase            =	''
		for _ in range(0       ,			32					):
				bit_string += str(number % 2					)
				UpperCamelCase            =	number >> 1
		return bit_string


def  A			(   lowercase					)  ->    str:
		'''simple docstring'''

		if number < 0:
				raise ValueError('the value of input must be positive'					)
		elif isinstance(lowercase       ,			lowercase					):
				raise TypeError('Input value must be a \'int\' type'					)
		elif isinstance(lowercase       ,			lowercase					):
				raise TypeError('\'<\' not supported between instances of \'str\' and \'int\''					)
		UpperCamelCase            =	0
		# iterator over [1 to 32],since we are dealing with 32 bit integer
		for _ in range(1       ,			33					):
				# left shift the bits by unity
				UpperCamelCase            =	result << 1
				# get the end bit
				UpperCamelCase            =	number % 2
				# right shift the bits by unity
				UpperCamelCase            =	number >> 1
				# add that bit to our ans
				UpperCamelCase            =	result | end_bit
		return get_reverse_bit_string(lowercase					)


if __name__ == "__main__":
					import doctest

					doctest.testmod()
