




"""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  _snake_case				:

				'''simple docstring'''




				def __init__(							self      :  Tuple					,							snake_case      :  int					,							snake_case      :  Dict=13					,							snake_case      :  List[Any]=32					,							snake_case      :  Union[str, Any]=2					,							snake_case      :  List[str]=3					,							snake_case      :  Any=16					,							snake_case      :  Any=[1, 2, 1]					,							snake_case      :  int=[2, 2, 4]					,							snake_case      :  Union[str, Any]=2					,							snake_case      :  Optional[Any]=2.0					,							snake_case      :  int=True					,							snake_case      :  Tuple=0.0					,							snake_case      :  Union[str, Any]=0.0					,							snake_case      :  int=0.1					,							snake_case      :  Any="gelu"					,							snake_case      :  Any=False					,							snake_case      :  List[Any]=True					,							snake_case      :  Optional[Any]=0.02					,							snake_case      :  Optional[Any]=1e-5					,							snake_case      :  str=True					,							snake_case      :  List[str]=None					,							snake_case      :  List[Any]=True					,							snake_case      :  Any=10					,							snake_case      :  Union[str, Any]=8					,							):
								UpperCAmelCase_					:Union[str, Any]      			=      parent
								UpperCAmelCase_					:Any      			=      batch_size
								UpperCAmelCase_					:List[str]      			=      image_size
								UpperCAmelCase_					:List[Any]      			=      patch_size
								UpperCAmelCase_					:Union[str, Any]      			=      num_channels
								UpperCAmelCase_					:Optional[Any]      			=      embed_dim
								UpperCAmelCase_					:str      			=      depths
								UpperCAmelCase_					:List[str]      			=      num_heads
								UpperCAmelCase_					:Tuple      			=      window_size
								UpperCAmelCase_					:Union[str, Any]      			=      mlp_ratio
								UpperCAmelCase_					:Union[str, Any]      			=      qkv_bias
								UpperCAmelCase_					:int      			=      hidden_dropout_prob
								UpperCAmelCase_					:Optional[Any]      			=      attention_probs_dropout_prob
								UpperCAmelCase_					:List[str]      			=      drop_path_rate
								UpperCAmelCase_					:List[str]      			=      hidden_act
								UpperCAmelCase_					:Tuple      			=      use_absolute_embeddings
								UpperCAmelCase_					:Optional[Any]      			=      patch_norm
								UpperCAmelCase_					:Tuple      			=      layer_norm_eps
								UpperCAmelCase_					:str      			=      initializer_range
								UpperCAmelCase_					:Union[str, Any]      			=      is_training
								UpperCAmelCase_					:int      			=      scope
								UpperCAmelCase_					:int      			=      use_labels
								UpperCAmelCase_					:Optional[Any]      			=      type_sequence_label_size
								UpperCAmelCase_					:Union[str, Any]      			=      encoder_stride





				def 				snake_case_ (							self      :  Tuple     ):
								UpperCAmelCase_					:str      			=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

								UpperCAmelCase_					:List[Any]      			=      None
								if self.use_labels:
												UpperCAmelCase_					:Tuple      			=      ids_tensor([self.batch_size]					,							self.type_sequence_label_size     )

								UpperCAmelCase_					:int      			=      self.get_config()

								return config, pixel_values, labels





				def 				snake_case_ (							self      :  List[str]     ):
								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      :  Dict					,							snake_case      :  List[str]					,							snake_case      :  Any					,							snake_case      :  List[Any]     ):
								UpperCAmelCase_					:Dict      			=      DonutSwinModel(config=snake_case     )
								model.to(snake_case     )
								model.eval()
								UpperCAmelCase_					:Dict      			=      model(snake_case     )

								UpperCAmelCase_					:Optional[Any]      			=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths     ) - 1))
								UpperCAmelCase_					:Dict      			=      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      :  Optional[Any]     ):
								UpperCAmelCase_					:Optional[Any]      			=      self.prepare_config_and_inputs()
								(
								    (
								    UpperCAmelCase_
								)			,(
								    UpperCAmelCase_
								)			,(
								    UpperCAmelCase_
								)			,
								)					:Optional[int]      			=      config_and_inputs
								UpperCAmelCase_					:Optional[int]      			=      {'''pixel_values''': pixel_values}
								return config, inputs_dict



@require_torch
class  _snake_case				(							A__							,						A__							,						unittest.TestCase       ):

				'''simple docstring'''




				UpperCamelCase__		     =(DonutSwinModel,) if is_torch_available() else ()
				UpperCamelCase__		     ={"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
				UpperCamelCase__		     =True

				UpperCamelCase__		     =False
				UpperCamelCase__		     =False
				UpperCamelCase__		     =False





				def 				snake_case_ (							self      :  Any     ):
								UpperCAmelCase_					:Optional[Any]      			=      DonutSwinModelTester(self     )
								UpperCAmelCase_					:Optional[int]      			=      ConfigTester(self					,							config_class=snake_case					,							embed_dim=37     )





				def 				snake_case_ (							self      :  Optional[Any]     ):
								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      :  Optional[Any]     ):
								return





				def 				snake_case_ (							self      :  List[Any]     ):
								UpperCAmelCase_					:Optional[Any]      			=      self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case     )





				def 				snake_case_ (							self      :  List[str]     ):
								# DonutSwin does not use inputs_embeds
								pass





				def 				snake_case_ (							self      :  Optional[Any]     ):
								UpperCAmelCase_			,UpperCAmelCase_					:Optional[int]      			=      self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
												UpperCAmelCase_					:Union[str, Any]      			=      model_class(snake_case     )
												self.assertIsInstance(model.get_input_embeddings()					,							(nn.Module)     )
												UpperCAmelCase_					:Optional[Any]      			=      model.get_output_embeddings()
												self.assertTrue(x is None or isinstance(snake_case					,							nn.Linear     )     )





				def 				snake_case_ (							self      :  Dict     ):
								UpperCAmelCase_			,UpperCAmelCase_					:Union[str, Any]      			=      self.model_tester.prepare_config_and_inputs_for_common()

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

												UpperCAmelCase_					:List[str]      			=      ['''pixel_values''']
												self.assertListEqual(arg_names[:1]					,							snake_case     )





				def 				snake_case_ (							self      :  Dict     ):
								UpperCAmelCase_			,UpperCAmelCase_					:Tuple      			=      self.model_tester.prepare_config_and_inputs_for_common()
								UpperCAmelCase_					:str      			=      True

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

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

												self.assertListEqual(
												    list(attentions[0].shape[-3:]     )					,							[self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,							)
												UpperCAmelCase_					:Optional[Any]      			=      len(snake_case     )

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

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

												UpperCAmelCase_					:List[str]      			=      outputs.attentions

												self.assertEqual(len(snake_case     )					,							snake_case     )

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





				def 				snake_case_ (							self      :  List[str]					,							snake_case      :  Optional[int]					,							snake_case      :  Optional[Any]					,							snake_case      :  int					,							snake_case      :  int     ):
								UpperCAmelCase_					:Dict      			=      model_class(snake_case     )
								model.to(snake_case     )
								model.eval()

								with torch.no_grad():
												UpperCAmelCase_					:Union[str, Any]      			=      model(**self._prepare_for_class(snake_case					,							snake_case     )     )

								UpperCAmelCase_					:Optional[int]      			=      outputs.hidden_states

								UpperCAmelCase_					:int      			=      getattr(
								    self.model_tester					,							'''expected_num_hidden_layers'''					,							len(self.model_tester.depths     ) + 1     )
								self.assertEqual(len(snake_case     )					,							snake_case     )

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

								UpperCAmelCase_					:int      			=      (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]					,							)

								UpperCAmelCase_					:Dict      			=      outputs.reshaped_hidden_states
								self.assertEqual(len(snake_case     )					,							snake_case     )

								UpperCAmelCase_			,UpperCAmelCase_			,UpperCAmelCase_			,UpperCAmelCase_					:List[Any]      			=      reshaped_hidden_states[0].shape
								UpperCAmelCase_					:int      			=      (
								    reshaped_hidden_states[0].view(snake_case					,							snake_case					,							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      :  Optional[Any]     ):
								UpperCAmelCase_			,UpperCAmelCase_					:int      			=      self.model_tester.prepare_config_and_inputs_for_common()

								UpperCAmelCase_					:Dict      			=      (
								    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:
												UpperCAmelCase_					:Any      			=      True
												self.check_hidden_states_output(snake_case					,							snake_case					,							snake_case					,							snake_case     )

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												UpperCAmelCase_					:int      			=      True

												self.check_hidden_states_output(snake_case					,							snake_case					,							snake_case					,							snake_case     )





				def 				snake_case_ (							self      :  str     ):
								UpperCAmelCase_			,UpperCAmelCase_					:Tuple      			=      self.model_tester.prepare_config_and_inputs_for_common()
								UpperCAmelCase_					:int      			=      3

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

								UpperCAmelCase_					:List[str]      			=      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
								UpperCAmelCase_					:Optional[Any]      			=      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

								for model_class in self.all_model_classes:
												UpperCAmelCase_					:int      			=      True
												self.check_hidden_states_output(snake_case					,							snake_case					,							snake_case					,							(padded_height, padded_width)     )

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												UpperCAmelCase_					:List[Any]      			=      True
												self.check_hidden_states_output(snake_case					,							snake_case					,							snake_case					,							(padded_height, padded_width)     )





				@slow
				def 				snake_case_ (							self      :  List[str]     ):
								for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												UpperCAmelCase_					:Optional[int]      			=      DonutSwinModel.from_pretrained(snake_case     )
												self.assertIsNotNone(snake_case     )





				def 				snake_case_ (							self      :  Any     ):
								UpperCAmelCase_			,UpperCAmelCase_					:Any      			=      self.model_tester.prepare_config_and_inputs_for_common()

								UpperCAmelCase_					:Dict      			=      _config_zero_init(snake_case     )
								for model_class in self.all_model_classes:
												UpperCAmelCase_					:Any      			=      model_class(config=snake_case     )
												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"""

def 				a (						__snake_case     :				int  ):



				'''simple docstring'''





				if not isinstance(__snake_case,    __snake_case  ) or number < 0:
								raise ValueError('''Input must be a non-negative integer'''  )

				UpperCAmelCase_					:Optional[Any]      			=      number & ~(number - 1)
				UpperCAmelCase_					:List[str]      			=      0
				while intermediate:
								intermediate >>= 1
								index += 1
				return index - 1


if __name__ == "__main__":
						import doctest

						doctest.testmod(verbose=True)


