

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


    '''simple docstring'''






    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       , )       -> int:
        __UpperCAmelCase			   =     parent
        __UpperCAmelCase			   =     batch_size
        __UpperCAmelCase			   =     image_size
        __UpperCAmelCase			   =     patch_size
        __UpperCAmelCase			   =     num_channels
        __UpperCAmelCase			   =     embed_dim
        __UpperCAmelCase			   =     depths
        __UpperCAmelCase			   =     num_heads
        __UpperCAmelCase			   =     window_size
        __UpperCAmelCase			   =     mlp_ratio
        __UpperCAmelCase			   =     qkv_bias
        __UpperCAmelCase			   =     hidden_dropout_prob
        __UpperCAmelCase			   =     attention_probs_dropout_prob
        __UpperCAmelCase			   =     drop_path_rate
        __UpperCAmelCase			   =     hidden_act
        __UpperCAmelCase			   =     use_absolute_embeddings
        __UpperCAmelCase			   =     patch_norm
        __UpperCAmelCase			   =     layer_norm_eps
        __UpperCAmelCase			   =     initializer_range
        __UpperCAmelCase			   =     is_training
        __UpperCAmelCase			   =     scope
        __UpperCAmelCase			   =     use_labels
        __UpperCAmelCase			   =     type_sequence_label_size
        __UpperCAmelCase			   =     encoder_stride


    def        lowerCAmelCase_  (self					)       -> Dict:
        __UpperCAmelCase			   =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

        __UpperCAmelCase			   =     self.get_config()

        return config, pixel_values, labels


    def        lowerCAmelCase_  (self					)       -> 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       , lowercase__       , lowercase__       , lowercase__					)       -> Any:
        __UpperCAmelCase			   =     DonutSwinModel(config=lowercase__					)
        model.to(lowercase__					)
        model.eval()
        __UpperCAmelCase			   =     model(lowercase__					)

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






@require_torch
class    A_				( snake_case__	,       snake_case__	,       unittest.TestCase  ):


    '''simple docstring'''






    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        lowerCAmelCase_  (self					)       -> Optional[Any]:
        __UpperCAmelCase			   =     DonutSwinModelTester(self					)
        __UpperCAmelCase			   =     ConfigTester(self       , config_class=lowercase__       , embed_dim=37					)


    def        lowerCAmelCase_  (self					)       -> int:
        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					)       -> Any:
        return


    def        lowerCAmelCase_  (self					)       -> Any:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowercase__					)


    def        lowerCAmelCase_  (self					)       -> Union[str, Any]:
        # DonutSwin does not use inputs_embeds
        pass


    def        lowerCAmelCase_  (self					)       -> Optional[Any]:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()

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


    def        lowerCAmelCase_  (self					)       -> str:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()

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

            __UpperCAmelCase			   =     ['pixel_values']
            self.assertListEqual(arg_names[:1]       , lowercase__					)


    def        lowerCAmelCase_  (self					)       -> Dict:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()
        __UpperCAmelCase			   =     True

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

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

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

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

            __UpperCAmelCase			   =     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        lowerCAmelCase_  (self       , lowercase__       , lowercase__       , lowercase__       , lowercase__					)       -> Tuple:
        __UpperCAmelCase			   =     model_class(lowercase__					)
        model.to(lowercase__					)
        model.eval()

        with torch.no_grad():
            __UpperCAmelCase			   =     model(**self._prepare_for_class(lowercase__       , lowercase__					)					)

        __UpperCAmelCase			   =     outputs.hidden_states

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

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

        __UpperCAmelCase			   =     reshaped_hidden_states[0].shape
        __UpperCAmelCase			   =     (
            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        lowerCAmelCase_  (self					)       -> Dict:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()

        __UpperCAmelCase			   =     (
            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			   =     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"]
            __UpperCAmelCase			   =     True

            self.check_hidden_states_output(lowercase__       , lowercase__       , lowercase__       , lowercase__					)


    def        lowerCAmelCase_  (self					)       -> List[Any]:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()
        __UpperCAmelCase			   =     3

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

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

        for model_class in self.all_model_classes:
            __UpperCAmelCase			   =     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"]
            __UpperCAmelCase			   =     True
            self.check_hidden_states_output(lowercase__       , lowercase__       , lowercase__       , (padded_height, padded_width)					)


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






    def        lowerCAmelCase_  (self					)       -> str:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()

        __UpperCAmelCase			   =     _config_zero_init(lowercase__					)
        for model_class in self.all_model_classes:
            __UpperCAmelCase			   =     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'''       , )






def  __a    (				SCREAMING_SNAKE_CASE ) ->       float:






    '''simple docstring'''
    return -num if num < 0 else num


def  __a    (				SCREAMING_SNAKE_CASE ) ->       int:






    '''simple docstring'''
    if len(SCREAMING_SNAKE_CASE ) == 0:
        raise ValueError('''abs_min() arg is an empty sequence''' )
    __UpperCAmelCase			   =     x[0]
    for i in x:
        if abs_val(SCREAMING_SNAKE_CASE ) < abs_val(SCREAMING_SNAKE_CASE ):
            __UpperCAmelCase			   =     i
    return j


def  __a    (				SCREAMING_SNAKE_CASE ) ->       int:






    '''simple docstring'''
    if len(SCREAMING_SNAKE_CASE ) == 0:
        raise ValueError('''abs_max() arg is an empty sequence''' )
    __UpperCAmelCase			   =     x[0]
    for i in x:
        if abs(SCREAMING_SNAKE_CASE ) > abs(SCREAMING_SNAKE_CASE ):
            __UpperCAmelCase			   =     i
    return j


def  __a    (				SCREAMING_SNAKE_CASE ) ->       int:






    '''simple docstring'''
    if len(SCREAMING_SNAKE_CASE ) == 0:
        raise ValueError('''abs_max_sort() arg is an empty sequence''' )
    return sorted(SCREAMING_SNAKE_CASE    ,				key=SCREAMING_SNAKE_CASE )[-1]


def  __a    (				) ->       Union[str, Any]:






    '''simple docstring'''
    assert abs_val(0 ) == 0
    assert abs_val(3_4 ) == 3_4
    assert abs_val(-1_0_0_0_0_0_0_0_0_0_0_0 ) == 1_0_0_0_0_0_0_0_0_0_0_0

    __UpperCAmelCase			   =     [-3, -1, 2, -1_1]
    assert abs_max(SCREAMING_SNAKE_CASE ) == -1_1
    assert abs_max_sort(SCREAMING_SNAKE_CASE ) == -1_1
    assert abs_min(SCREAMING_SNAKE_CASE ) == -1


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       test_abs_val()
       print(abs_val(-34))  # --> 34




