




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




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


									'''simple docstring'''


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




					def     _lowercase						(   self:		Tuple):


									'''simple docstring'''


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

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

									__lowerCAmelCase					=  self.get_config()

									return config, pixel_values, labels




					def     _lowercase						(   self:		List[str]):


									'''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:		str,     _lowercase:		int,     _lowercase:		List[Any],     _lowercase:		Any):


									'''simple docstring'''


									__lowerCAmelCase					=  DonutSwinModel(config=_lowercase)
									model.to(_lowercase)
									model.eval()
									__lowerCAmelCase					=  model(_lowercase)

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


									'''simple docstring'''


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





@require_torch
class 		lowercase_       (	lowerCAmelCase__						,							lowerCAmelCase__						,							unittest.TestCase				):
					__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     _lowercase						(   self:		int):


									'''simple docstring'''


									__lowerCAmelCase					=  DonutSwinModelTester(self)
									__lowerCAmelCase					=  ConfigTester(self,     config_class=_lowercase,     embed_dim=37)




					def     _lowercase						(   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     _lowercase						(   self:		Any):


									'''simple docstring'''


									return




					def     _lowercase						(   self:		str):


									'''simple docstring'''


									__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_lowercase)




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


									'''simple docstring'''


									pass




					def     _lowercase						(   self:		List[str]):


									'''simple docstring'''


									__lowerCAmelCase	,				__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

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




					def     _lowercase						(   self:		Dict):


									'''simple docstring'''


									__lowerCAmelCase	,				__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

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

													__lowerCAmelCase					=  ["""pixel_values"""]
													self.assertListEqual(arg_names[:1],     _lowercase)




					def     _lowercase						(   self:		int):


									'''simple docstring'''


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

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

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

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

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

													__lowerCAmelCase					=  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:		int,     _lowercase:		List[str],     _lowercase:		Any,     _lowercase:		List[Any],     _lowercase:		Optional[Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  model_class(_lowercase)
									model.to(_lowercase)
									model.eval()

									with torch.no_grad():
													__lowerCAmelCase					=  model(**self._prepare_for_class(_lowercase,     _lowercase))

									__lowerCAmelCase					=  outputs.hidden_states

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

									__lowerCAmelCase					=  (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					=  outputs.reshaped_hidden_states
									self.assertEqual(len(_lowercase),     _lowercase)

									__lowerCAmelCase	,				__lowerCAmelCase	,				__lowerCAmelCase	,				__lowerCAmelCase					=  reshaped_hidden_states[0].shape
									__lowerCAmelCase					=  (
									    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:		int):


									'''simple docstring'''


									__lowerCAmelCase	,				__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

									__lowerCAmelCase					=  (
									    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					=  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					=  True

													self.check_hidden_states_output(_lowercase,     _lowercase,     _lowercase,     _lowercase)




					def     _lowercase						(   self:		Dict):


									'''simple docstring'''


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

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

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

									for model_class in self.all_model_classes:
													__lowerCAmelCase					=  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					=  True
													self.check_hidden_states_output(_lowercase,     _lowercase,     _lowercase,     (padded_height, padded_width))




					@slow
					def     _lowercase						(   self:		Union[str, Any]):


									'''simple docstring'''


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







					def     _lowercase						(   self:		List[str]):


									'''simple docstring'''


									__lowerCAmelCase	,				__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

									__lowerCAmelCase					=  _config_zero_init(_lowercase)
									for model_class in self.all_model_classes:
													__lowerCAmelCase					=  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 __future__ import annotations

# Define the Gravitational Constant G and the function
__magic_name__       =     6.6743E-11  # unit of G : m^3 * kg^-1 * s^-2





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					lowercase						   =       mass_a * mass_a

					if (force, mass_a, mass_a, distance).count(0				) != 1:
										raise ValueError('One and only one argument must be 0'				)
					if force < 0:
										raise ValueError('Gravitational force can not be negative'				)
					if distance < 0:
										raise ValueError('Distance can not be negative'				)
					if mass_a < 0 or mass_a < 0:
										raise ValueError('Mass can not be negative'				)
					if force == 0:
										lowercase						   =       GRAVITATIONAL_CONSTANT * product_of_mass / (distance**2)
										return {"force": force}
					elif mass_a == 0:
										lowercase						   =       (force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
										return {"mass_1": mass_a}
					elif mass_a == 0:
										lowercase						   =       (force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
										return {"mass_2": mass_a}
					elif distance == 0:
										lowercase						   =       (GRAVITATIONAL_CONSTANT * product_of_mass / (force)) ** 0.5
										return {"distance": distance}
					raise ValueError('One and only one argument must be 0'				)


# Run doctest
if __name__ == "__main__":
		import doctest

		doctest.testmod()






