



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






					'''simple docstring'''





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






					def   lowerCAmelCase_							(			self:				Union[str, Any]		)  ->      Dict:
											snake_case_					:Dict		=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

											snake_case_					:Optional[int]		=     self.get_config()

											return config, pixel_values, labels






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

											snake_case_					:List[Any]		=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths		) - 1))
											snake_case_					:str		=     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   lowerCAmelCase_							(			self:				Union[str, Any]		)  ->      str:
											snake_case_					:List[Any]		=     self.prepare_config_and_inputs()
											(
											    (
											    snake_case_
											),			(
											    snake_case_
											),			(
											    snake_case_
											),			
											)					:List[str]		=     config_and_inputs
											snake_case_					:Optional[Any]		=     {"""pixel_values""": pixel_values}
											return config, inputs_dict

@require_torch
class 							lowerCamelCase    (     _lowerCAmelCase       ,		_lowerCAmelCase       ,		unittest.TestCase							):






					'''simple docstring'''





					_A						:     int		=	(DonutSwinModel,) if is_torch_available() else ()
					_A						:     Tuple		=	{"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
					_A						:     List[str]		=	True

					_A						:     Union[str, Any]		=	False
					_A						:     Optional[int]		=	False
					_A						:     Optional[Any]		=	False






					def   lowerCAmelCase_							(			self:				List[str]		)  ->      List[Any]:
											snake_case_					:Union[str, Any]		=     DonutSwinModelTester(self		)
											snake_case_					:Union[str, Any]		=     ConfigTester(self		,	config_class=snake_case		,	embed_dim=37		)






					def   lowerCAmelCase_							(			self:				List[Any]		)  ->      str:
											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   lowerCAmelCase_							(			self:				str		)  ->      List[str]:
											return






					def   lowerCAmelCase_							(			self:				Tuple		)  ->      Optional[int]:
											snake_case_					:Any		=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case		)






					def   lowerCAmelCase_							(			self:				Tuple		)  ->      Dict:
											# DonutSwin does not use inputs_embeds
											pass






					def   lowerCAmelCase_							(			self:				int		)  ->      Union[str, Any]:
											snake_case_,			snake_case_					:Union[str, Any]		=     self.model_tester.prepare_config_and_inputs_for_common()

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






					def   lowerCAmelCase_							(			self:				List[str]		)  ->      Dict:
											snake_case_,			snake_case_					:List[str]		=     self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	snake_case_					:int		=     model_class(snake_case		)
																	snake_case_					:Tuple		=     inspect.signature(model.forward		)
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	snake_case_					:Union[str, Any]		=     [*signature.parameters.keys()]

																	snake_case_					:Optional[int]		=     ["""pixel_values"""]
																	self.assertListEqual(arg_names[:1]		,	snake_case		)






					def   lowerCAmelCase_							(			self:				str		)  ->      List[str]:
											snake_case_,			snake_case_					:Any		=     self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_					:List[str]		=     True

											for model_class in self.all_model_classes:
																	snake_case_					:Dict		=     True
																	snake_case_					:int		=     False
																	snake_case_					:Any		=     True
																	snake_case_					:List[str]		=     model_class(snake_case		)
																	model.to(snake_case		)
																	model.eval()
																	with torch.no_grad():
																							snake_case_					:Optional[Any]		=     model(**self._prepare_for_class(snake_case		,	snake_case		)		)
																	snake_case_					:Dict		=     outputs.attentions
																	snake_case_					:Optional[Any]		=     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"]
																	snake_case_					:str		=     True
																	snake_case_					:Dict		=     config.window_size**2
																	snake_case_					:Tuple		=     model_class(snake_case		)
																	model.to(snake_case		)
																	model.eval()
																	with torch.no_grad():
																							snake_case_					:Any		=     model(**self._prepare_for_class(snake_case		,	snake_case		)		)
																	snake_case_					:Optional[int]		=     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]		,	)
																	snake_case_					:Union[str, Any]		=     len(snake_case		)

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

																	if hasattr(self.model_tester		,	"""num_hidden_states_types"""		):
																							snake_case_					:Union[str, Any]		=     self.model_tester.num_hidden_states_types
																	else:
																							# also another +1 for reshaped_hidden_states
																							snake_case_					:Tuple		=     2
																	self.assertEqual(out_len + added_hidden_states		,	len(snake_case		)		)

																	snake_case_					:Tuple		=     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   lowerCAmelCase_							(			self:				Optional[int]		,	snake_case:				int		,	snake_case:				Optional[int]		,	snake_case:				str		,	snake_case:				Union[str, Any]		)  ->      Tuple:
											snake_case_					:Optional[Any]		=     model_class(snake_case		)
											model.to(snake_case		)
											model.eval()

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

											snake_case_					:Optional[int]		=     outputs.hidden_states

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

											snake_case_					:Union[str, Any]		=     (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_					:Tuple		=     outputs.reshaped_hidden_states
											self.assertEqual(len(snake_case		)		,	snake_case		)

											snake_case_,			snake_case_,			snake_case_,			snake_case_					:Dict		=     reshaped_hidden_states[0].shape
											snake_case_					:Dict		=     (
											    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   lowerCAmelCase_							(			self:				Any		)  ->      Tuple:
											snake_case_,			snake_case_					:Optional[int]		=     self.model_tester.prepare_config_and_inputs_for_common()

											snake_case_					: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)
											)

											for model_class in self.all_model_classes:
																	snake_case_					:int		=     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"]
																	snake_case_					:Tuple		=     True

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






					def   lowerCAmelCase_							(			self:				str		)  ->      Dict:
											snake_case_,			snake_case_					:str		=     self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_					:Dict		=     3

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

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

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






					@slow
					def   lowerCAmelCase_							(			self:				Optional[int]		)  ->      Any:
											for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_					:Tuple		=     DonutSwinModel.from_pretrained(snake_case		)
																	self.assertIsNotNone(snake_case		)






					def   lowerCAmelCase_							(			self:				Tuple		)  ->      int:
											snake_case_,			snake_case_					:Optional[int]		=     self.model_tester.prepare_config_and_inputs_for_common()

											snake_case_					:List[Any]		=     _config_zero_init(snake_case		)
											for model_class in self.all_model_classes:
																	snake_case_					: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"""




__lowerCAmelCase							:  Any 				=		{
    '''0''': 1,
    '''1''': 1,
    '''2''': 2,
    '''3''': 6,
    '''4''': 24,
    '''5''': 120,
    '''6''': 720,
    '''7''': 5040,
    '''8''': 40320,
    '''9''': 362880,
}

__lowerCAmelCase							:  List[Any] 				=		{145: 145}

__lowerCAmelCase							:  Any 				=		{
    145: 0,
    169: 3,
    36301: 3,
    1454: 3,
    871: 2,
    45361: 2,
    872: 2,
}

def __snake_case (      UpperCamelCase    )       ->    int:


		"""simple docstring"""





		if n in CACHE_SUM_DIGIT_FACTORIALS:
				return CACHE_SUM_DIGIT_FACTORIALS[n]
		a__   		=     sum(DIGIT_FACTORIALS[let] for let in str(UpperCamelCase    )    )
		a__   		=     ret
		return ret

def __snake_case (      UpperCamelCase						,					UpperCamelCase = None    )       ->    int:


		"""simple docstring"""





		a__   		=     previous or set()
		if n in CHAIN_LENGTH_CACHE:
				return CHAIN_LENGTH_CACHE[n]
		a__   		=     sum_digit_factorials(UpperCamelCase    )
		if next_number in previous:
				a__   		=     0
				return 0
		else:
				previous.add(UpperCamelCase    )
				a__   		=     1 + chain_length(UpperCamelCase						,					UpperCamelCase    )
				a__   		=     ret
				return ret

def __snake_case (      UpperCamelCase = 60						,					UpperCamelCase = 1_000_000    )       ->    int:


		"""simple docstring"""





		return sum(1 for i in range(1						,					UpperCamelCase    ) if chain_length(UpperCamelCase    ) == num_terms    )


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




