

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     ,      )     ->      str:
        __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  )     ->      Any:
        __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  )     ->      Tuple:
        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__  )     ->      List[str]:
        __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  )     ->      str:
        __UpperCAmelCase									=			self.prepare_config_and_inputs()
        (
            (
            __UpperCAmelCase
        )					,     (
            __UpperCAmelCase
        )					,     (
            __UpperCAmelCase
        )					,     
        )									=			config_and_inputs
        __UpperCAmelCase									=			{'''pixel_values''': pixel_values}
        return config, inputs_dict






@require_torch
class 					A_   (      _a ,     _a ,     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  )     ->      Union[str, Any]:
        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  )     ->      Optional[int]:
        return


    def      lowerCAmelCase_						(self  )     ->      Union[str, Any]:
        __UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowercase__  )


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


    def      lowerCAmelCase_						(self  )     ->      Union[str, Any]:
        __UpperCAmelCase					,     __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  )     ->      Tuple:
        __UpperCAmelCase					,     __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  )     ->      Optional[Any]:
        __UpperCAmelCase					,     __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__  )     ->      List[str]:
        __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					,     __UpperCAmelCase					,     __UpperCAmelCase					,     __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  )     ->      Any:
        __UpperCAmelCase					,     __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  )     ->      int:
        __UpperCAmelCase					,     __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  )     ->      Tuple:
        for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __UpperCAmelCase									=			DonutSwinModel.from_pretrained(lowercase__  )
            self.assertIsNotNone(lowercase__  )






    def      lowerCAmelCase_						(self  )     ->      Tuple:
        __UpperCAmelCase					,     __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'''     ,      )







import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


A_		:			int										=   logging.get_logger(__name__)
class 					A_   (      _a						):


    '''simple docstring'''






    a__     							=       "speech-encoder-decoder"
    a__     							=       True


    def __init__(self     ,      **lowercase__  )     ->      Optional[int]:
        super().__init__(**lowercase__  )
        if "encoder" not in kwargs or "decoder" not in kwargs:
            raise ValueError(
                F'''A configuraton of type {self.model_type} cannot be instantiated because not both `encoder` and'''
                F''' `decoder` sub-configurations are passed, but only {kwargs}'''  )

        __UpperCAmelCase									=			kwargs.pop('''encoder'''  )
        __UpperCAmelCase									=			encoder_config.pop('''model_type'''  )
        __UpperCAmelCase									=			kwargs.pop('''decoder'''  )
        __UpperCAmelCase									=			decoder_config.pop('''model_type'''  )

        __UpperCAmelCase									=			AutoConfig.for_model(lowercase__     ,      **lowercase__  )
        __UpperCAmelCase									=			AutoConfig.for_model(lowercase__     ,      **lowercase__  )
        __UpperCAmelCase									=			True


    @classmethod
    def      lowerCAmelCase_						(cls     ,      lowercase__     ,      lowercase__     ,      **lowercase__  )     ->      PretrainedConfig:
        logger.info('''Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'''  )
        __UpperCAmelCase									=			True
        __UpperCAmelCase									=			True

        return cls(encoder=encoder_config.to_dict()     ,      decoder=decoder_config.to_dict()     ,      **lowercase__  )






    def      lowerCAmelCase_						(self  )     ->      Optional[Any]:
        __UpperCAmelCase									=			copy.deepcopy(self.__dict__  )
        __UpperCAmelCase									=			self.encoder.to_dict()
        __UpperCAmelCase									=			self.decoder.to_dict()
        __UpperCAmelCase									=			self.__class__.model_type
        return output




