
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 ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__=13 ,	SCREAMING_SNAKE_CASE__=32 ,	SCREAMING_SNAKE_CASE__=2 ,	SCREAMING_SNAKE_CASE__=3 ,	SCREAMING_SNAKE_CASE__=16 ,	SCREAMING_SNAKE_CASE__=[1, 2, 1] ,	SCREAMING_SNAKE_CASE__=[2, 2, 4] ,	SCREAMING_SNAKE_CASE__=2 ,	SCREAMING_SNAKE_CASE__=2.0 ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=0.0 ,	SCREAMING_SNAKE_CASE__=0.0 ,	SCREAMING_SNAKE_CASE__=0.1 ,	SCREAMING_SNAKE_CASE__="gelu" ,	SCREAMING_SNAKE_CASE__=False ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=0.02 ,	SCREAMING_SNAKE_CASE__=1E-5 ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=None ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=10 ,	SCREAMING_SNAKE_CASE__=8 ,	):
        """simple docstring"""







        lowerCAmelCase__ :    Any				      =			parent
        lowerCAmelCase__ :    str				      =			batch_size
        lowerCAmelCase__ :    Tuple				      =			image_size
        lowerCAmelCase__ :    Union[str, Any]				      =			patch_size
        lowerCAmelCase__ :    int				      =			num_channels
        lowerCAmelCase__ :    Tuple				      =			embed_dim
        lowerCAmelCase__ :    Optional[int]				      =			depths
        lowerCAmelCase__ :    Tuple				      =			num_heads
        lowerCAmelCase__ :    Tuple				      =			window_size
        lowerCAmelCase__ :    Dict				      =			mlp_ratio
        lowerCAmelCase__ :    int				      =			qkv_bias
        lowerCAmelCase__ :    Dict				      =			hidden_dropout_prob
        lowerCAmelCase__ :    Dict				      =			attention_probs_dropout_prob
        lowerCAmelCase__ :    Tuple				      =			drop_path_rate
        lowerCAmelCase__ :    int				      =			hidden_act
        lowerCAmelCase__ :    Union[str, Any]				      =			use_absolute_embeddings
        lowerCAmelCase__ :    Dict				      =			patch_norm
        lowerCAmelCase__ :    Any				      =			layer_norm_eps
        lowerCAmelCase__ :    Tuple				      =			initializer_range
        lowerCAmelCase__ :    Optional[Any]				      =			is_training
        lowerCAmelCase__ :    str				      =			scope
        lowerCAmelCase__ :    List[str]				      =			use_labels
        lowerCAmelCase__ :    Optional[Any]				      =			type_sequence_label_size
        lowerCAmelCase__ :    int				      =			encoder_stride
     def lowercase_			(		self    ):
        """simple docstring"""







        lowerCAmelCase__ :    List[str]				      =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

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

        lowerCAmelCase__ :    Tuple				      =			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 ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    ):
        """simple docstring"""







        lowerCAmelCase__ :    Optional[Any]				      =			DonutSwinModel(config=SCREAMING_SNAKE_CASE__    )
        model.to(SCREAMING_SNAKE_CASE__    )
        model.eval()
        lowerCAmelCase__ :    Optional[Any]				      =			model(SCREAMING_SNAKE_CASE__    )

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





@require_torch
class 						lowercase       (  __UpperCamelCase	,		__UpperCamelCase	,		unittest.TestCase					):
     __a					=    (DonutSwinModel,) if is_torch_available() else ()
     __a					=    {"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
     __a					=    True

     __a					=    False
     __a					=    False
     __a					=    False
     def lowercase_			(		self    ):
        """simple docstring"""







        lowerCAmelCase__ :    List[str]				      =			DonutSwinModelTester(self    )
        lowerCAmelCase__ :    Union[str, Any]				      =			ConfigTester(self ,	config_class=SCREAMING_SNAKE_CASE__ ,	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__ :    int				      =			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__    )
     def lowercase_			(		self    ):
        """simple docstring"""







        pass
     def lowercase_			(		self    ):
        """simple docstring"""







        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(SCREAMING_SNAKE_CASE__    )
           self.assertIsInstance(model.get_input_embeddings() ,	(nn.Module)    )
           lowerCAmelCase__ :    Dict				      =			model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__ ,	nn.Linear    )    )
     def lowercase_			(		self    ):
        """simple docstring"""







        lowerCAmelCase__ :    Tuple				      =			self.model_tester.prepare_config_and_inputs_for_common()

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

           lowerCAmelCase__ :    List[str]				      =			['''pixel_values''']
           self.assertListEqual(arg_names[:1] ,	SCREAMING_SNAKE_CASE__    )
     def lowercase_			(		self    ):
        """simple docstring"""







        lowerCAmelCase__ :    str				      =			self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase__ :    List[Any]				      =			True

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

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

           self.assertListEqual(
               list(attentions[0].shape[-3:]    ) ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,	)
           lowerCAmelCase__ :    Optional[int]				      =			len(SCREAMING_SNAKE_CASE__    )

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

           if hasattr(self.model_tester ,	'''num_hidden_states_types'''    ):
              lowerCAmelCase__ :    Tuple				      =			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(SCREAMING_SNAKE_CASE__    )    )

           lowerCAmelCase__ :    List[str]				      =			outputs.attentions

           self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

           self.assertListEqual(
               list(self_attentions[0].shape[-3:]    ) ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,	)
     def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    ):
        """simple docstring"""







        lowerCAmelCase__ :    Tuple				      =			model_class(SCREAMING_SNAKE_CASE__    )
        model.to(SCREAMING_SNAKE_CASE__    )
        model.eval()

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

        lowerCAmelCase__ :    List[str]				      =			outputs.hidden_states

        lowerCAmelCase__ :    Optional[Any]				      =			getattr(
            self.model_tester ,	'''expected_num_hidden_layers''' ,	len(self.model_tester.depths    ) + 1    )
        self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

        # 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__ :    List[str]				      =			outputs.reshaped_hidden_states
        self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

        lowerCAmelCase__ :    List[str]				      =			reshaped_hidden_states[0].shape
        lowerCAmelCase__ :    Dict				      =			(
            reshaped_hidden_states[0].view(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	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__ :    List[str]				      =			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(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

           # 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(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )
     def lowercase_			(		self    ):
        """simple docstring"""







        lowerCAmelCase__ :    Dict				      =			self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase__ :    Union[str, Any]				      =			3

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

        lowerCAmelCase__ :    Optional[int]				      =			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
        lowerCAmelCase__ :    Any				      =			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(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	(padded_height, padded_width)    )

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           lowerCAmelCase__ :    Dict				      =			True
           self.check_hidden_states_output(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	(padded_height, padded_width)    )
     @slow
     def lowercase_			(		self    ):
        """simple docstring"""







        for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           lowerCAmelCase__ :    Optional[Any]				      =			DonutSwinModel.from_pretrained(SCREAMING_SNAKE_CASE__    )
           self.assertIsNotNone(SCREAMING_SNAKE_CASE__    )
     def lowercase_			(		self    ):
        """simple docstring"""







        lowerCAmelCase__ :    Any				      =			self.model_tester.prepare_config_and_inputs_for_common()

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





import abc
import copy
import dataclasses
from dataclasses import dataclass
from typing import ClassVar, Dict, Type, TypeVar

from ..features import Features


A__       :   Tuple   						=					TypeVar("""T""", bound="""TaskTemplate""")





@dataclass(frozen=__UpperCamelCase					)
class 						lowercase       (  abc.ABC					):
					# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
					__a					=    42
					__a					=    42
					__a					=    42
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								return copy.deepcopy(self    )
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								return Features(**self.input_schema ,	**self.label_schema    )
					@property
					@abc.abstractmethod
					def lowercase_			(		self    ):
								"""simple docstring"""







								raise NotImplementedError
					@classmethod
					def lowercase_			(		cls ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    List[Any]				      =			{f.name for f in dataclasses.fields(cls    )}
								return cls(**{k: v for k, v in template_dict.items() if k in field_names}    )



