





from __future__ import annotations






def 				_lowerCAmelCase			(	_a :       list[int | float]      )						->      int | float:
     if len(_a      ) == 0:
          raise ValueError("""find_max() arg is an empty sequence"""      )
     lowerCAmelCase_       :							Optional[Any]			 =		nums[0]
     for x in nums:
          if x > max_num:
               lowerCAmelCase_       :							int			 =		x
     return max_num


if __name__ == "__main__":
      import doctest

      doctest.testmod(verbose=True)







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     ,    _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     ,    ):
       lowerCAmelCase_       :							List[str]			 =		parent
       lowerCAmelCase_       :							int			 =		batch_size
       lowerCAmelCase_       :							str			 =		image_size
       lowerCAmelCase_       :							Any			 =		patch_size
       lowerCAmelCase_       :							Dict			 =		num_channels
       lowerCAmelCase_       :							str			 =		embed_dim
       lowerCAmelCase_       :							Tuple			 =		depths
       lowerCAmelCase_       :							int			 =		num_heads
       lowerCAmelCase_       :							str			 =		window_size
       lowerCAmelCase_       :							str			 =		mlp_ratio
       lowerCAmelCase_       :							List[Any]			 =		qkv_bias
       lowerCAmelCase_       :							Tuple			 =		hidden_dropout_prob
       lowerCAmelCase_       :							int			 =		attention_probs_dropout_prob
       lowerCAmelCase_       :							Union[str, Any]			 =		drop_path_rate
       lowerCAmelCase_       :							List[str]			 =		hidden_act
       lowerCAmelCase_       :							str			 =		use_absolute_embeddings
       lowerCAmelCase_       :							Union[str, Any]			 =		patch_norm
       lowerCAmelCase_       :							Tuple			 =		layer_norm_eps
       lowerCAmelCase_       :							Optional[Any]			 =		initializer_range
       lowerCAmelCase_       :							Optional[int]			 =		is_training
       lowerCAmelCase_       :							Optional[int]			 =		scope
       lowerCAmelCase_       :							Any			 =		use_labels
       lowerCAmelCase_       :							Dict			 =		type_sequence_label_size
       lowerCAmelCase_       :							str			 =		encoder_stride







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_       :							Any			 =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

       lowerCAmelCase_       :							str			 =		None
       if self.use_labels:
            lowerCAmelCase_       :							Dict			 =		ids_tensor([self.batch_size]     ,    self.type_sequence_label_size    )

       lowerCAmelCase_       :							List[Any]			 =		self.get_config()

       return config, pixel_values, labels







  def 						UpperCAmelCase__		(						self    ):
       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 						UpperCAmelCase__		(						self     ,    _lowercase     ,    _lowercase     ,    _lowercase    ):
       lowerCAmelCase_       :							Optional[Any]			 =		DonutSwinModel(config=_lowercase    )
       model.to(_lowercase    )
       model.eval()
       lowerCAmelCase_       :							Optional[Any]			 =		model(_lowercase    )

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





@require_torch
class   lowercase__     (				__A  ,       __A  ,       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 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_       :							Tuple			 =		DonutSwinModelTester(self    )
       lowerCAmelCase_       :							Optional[Any]			 =		ConfigTester(self     ,    config_class=_lowercase     ,    embed_dim=37    )







  def 						UpperCAmelCase__		(						self    ):
       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 						UpperCAmelCase__		(						self    ):
       return







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_       :							Tuple			 =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowercase    )







  def 						UpperCAmelCase__		(						self    ):
       # DonutSwin does not use inputs_embeds
       pass







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							str			 =		self.model_tester.prepare_config_and_inputs_for_common()

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







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							List[Any]			 =		self.model_tester.prepare_config_and_inputs_for_common()

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

            lowerCAmelCase_       :							Union[str, Any]			 =		["""pixel_values"""]
            self.assertListEqual(arg_names[:1]     ,    _lowercase    )







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							Optional[Any]			 =		self.model_tester.prepare_config_and_inputs_for_common()
       lowerCAmelCase_       :							Tuple			 =		True

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

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

            # Check attention is always last and order is fine
            lowerCAmelCase_       :							int			 =		True
            lowerCAmelCase_       :							str			 =		True
            lowerCAmelCase_       :							Tuple			 =		model_class(_lowercase    )
            model.to(_lowercase    )
            model.eval()
            with torch.no_grad():
                 lowerCAmelCase_       :							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_       :							Union[str, Any]			 =		2
            self.assertEqual(out_len + added_hidden_states     ,    len(_lowercase    )    )

            lowerCAmelCase_       :							Any			 =		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 						UpperCAmelCase__		(						self     ,    _lowercase     ,    _lowercase     ,    _lowercase     ,    _lowercase    ):
       lowerCAmelCase_       :							Optional[Any]			 =		model_class(_lowercase    )
       model.to(_lowercase    )
       model.eval()

       with torch.no_grad():
            lowerCAmelCase_       :							List[str]			 =		model(**self._prepare_for_class(_lowercase     ,    _lowercase    )    )

       lowerCAmelCase_       :							List[Any]			 =		outputs.hidden_states

       lowerCAmelCase_       :							str			 =		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_       :							List[str]			 =		(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_       :							List[Any]			 =		outputs.reshaped_hidden_states
       self.assertEqual(len(_lowercase    )     ,    _lowercase    )

       lowerCAmelCase_ ,	lowerCAmelCase_ ,	lowerCAmelCase_ ,	lowerCAmelCase_       :							Optional[Any]			 =		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 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							Dict			 =		self.model_tester.prepare_config_and_inputs_for_common()

       lowerCAmelCase_       :							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_       :							Any			 =		True

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







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							int			 =		self.model_tester.prepare_config_and_inputs_for_common()
       lowerCAmelCase_       :							int			 =		3

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

       lowerCAmelCase_       :							int			 =		image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       lowerCAmelCase_       :							int			 =		image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

       for model_class in self.all_model_classes:
            lowerCAmelCase_       :							Tuple			 =		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_       :							Union[str, Any]			 =		True
            self.check_hidden_states_output(_lowercase     ,    _lowercase     ,    _lowercase     ,    (padded_height, padded_width)    )







  @slow
  def 						UpperCAmelCase__		(						self    ):
       for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            lowerCAmelCase_       :							str			 =		DonutSwinModel.from_pretrained(_lowercase    )
            self.assertIsNotNone(_lowercase    )







  def 						UpperCAmelCase__		(						self    ):
       lowerCAmelCase_ ,	lowerCAmelCase_       :							List[str]			 =		self.model_tester.prepare_config_and_inputs_for_common()

       lowerCAmelCase_       :							str			 =		_config_zero_init(_lowercase    )
       for model_class in self.all_model_classes:
            lowerCAmelCase_       :							Union[str, Any]			 =		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'     ,    )
