


import json
import os
import re
import warnings
from pathlib import Path
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple, Union

import sentencepiece

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__lowerCamelCase   	=  logging.get_logger(__name__)

__lowerCamelCase   	=  {
    '''source_spm''': '''source.spm''',
    '''target_spm''': '''target.spm''',
    '''vocab''': '''vocab.json''',
    '''target_vocab_file''': '''target_vocab.json''',
    '''tokenizer_config_file''': '''tokenizer_config.json''',
}

__lowerCamelCase   	=  {
    '''source_spm''': {
        '''Helsinki-NLP/opus-mt-en-de''': '''https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/source.spm'''
    },
    '''target_spm''': {
        '''Helsinki-NLP/opus-mt-en-de''': '''https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/target.spm'''
    },
    '''vocab''': {
        '''Helsinki-NLP/opus-mt-en-de''': '''https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/vocab.json'''
    },
    '''tokenizer_config_file''': {
        '''Helsinki-NLP/opus-mt-en-de''': (
            '''https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/tokenizer_config.json'''
        )
    },
}

__lowerCamelCase   	=  {'''Helsinki-NLP/opus-mt-en-de''': 512}
__lowerCamelCase   	=  {}


class 	a__						(    lowerCAmelCase_     ):
       lowerCamelCase__:  List[Any]				     =  VOCAB_FILES_NAMES
       lowerCamelCase__:  Optional[int]				     =  PRETRAINED_VOCAB_FILES_MAP
       lowerCamelCase__:  Optional[Any]				     =  PRETRAINED_INIT_CONFIGURATION
       lowerCamelCase__:  int				     =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       lowerCamelCase__:  Dict				     =  ["""input_ids""", """attention_mask"""]
       lowerCamelCase__:  Optional[int]				     =  re.compile(""">>.+<<"""     )  # type: re.Pattern

       def __init__( self   :  str   ,				lowerCamelCase_   :  int   ,				lowerCamelCase_   :  Dict   ,				lowerCamelCase_   :  int   ,				lowerCamelCase_   :  int=None   ,				lowerCamelCase_   :  int=None   ,				lowerCamelCase_   :  Optional[Any]=None   ,				lowerCamelCase_   :  List[Any]="<unk>"   ,				lowerCamelCase_   :  Optional[Any]="</s>"   ,				lowerCamelCase_   :  Tuple="<pad>"   ,				lowerCamelCase_   :  Dict=5_1_2   ,				lowerCamelCase_   :  Optional[Dict[str, Any]] = None   ,				lowerCamelCase_   :  List[str]=False   ,				**lowerCamelCase_   :  int   ,				):
            a_     :  List[str]				      =     {} if sp_model_kwargs is None else sp_model_kwargs

            super().__init__(
                # bos_token=bos_token,  unused. Start decoding with config.decoder_start_token_id
                source_lang=lowerCamelCase_   ,				target_lang=lowerCamelCase_   ,				unk_token=lowerCamelCase_   ,				eos_token=lowerCamelCase_   ,				pad_token=lowerCamelCase_   ,				model_max_length=lowerCamelCase_   ,				sp_model_kwargs=self.sp_model_kwargs   ,				target_vocab_file=lowerCamelCase_   ,				separate_vocabs=lowerCamelCase_   ,				**lowerCamelCase_   ,				)
            assert Path(lowerCamelCase_     ).exists(), F'''cannot find spm source {source_spm}'''

            a_     :  int				      =     separate_vocabs
            a_     :  Optional[int]				      =     load_json(lowerCamelCase_     )
            if self.unk_token not in self.encoder:
                 raise KeyError("""<unk> token must be in vocab"""     )
            assert self.pad_token in self.encoder

            if separate_vocabs:
                 a_     :  Dict				      =     load_json(lowerCamelCase_     )
                 a_     :  int				      =     {v: k for k, v in self.target_encoder.items()}
                 a_     :  Any				      =     []
            else:
                 a_     :  Any				      =     {v: k for k, v in self.encoder.items()}
                 a_     :  list				      =     [k for k in self.encoder if k.startswith(""">>"""     ) and k.endswith("""<<"""     )]

            a_     :  Dict				      =     source_lang
            a_     :  Any				      =     target_lang
            a_     :  str				      =     [source_spm, target_spm]

            # load SentencePiece model for pre-processing
            a_     :  str				      =     load_spm(lowerCamelCase_   ,				self.sp_model_kwargs     )
            a_     :  Any				      =     load_spm(lowerCamelCase_   ,				self.sp_model_kwargs     )
            a_     :  Tuple				      =     self.spm_source
            a_     :  Tuple				      =     self.encoder

            # Multilingual target side: default to using first supported language code.

            self._setup_normalizer()

       def     UpperCAmelCase( self   :  Tuple     ):
            try:
                 from sacremoses import MosesPunctNormalizer

                 a_     :  Union[str, Any]				      =     MosesPunctNormalizer(self.source_lang     ).normalize
            except (ImportError, FileNotFoundError):
                 warnings.warn("""Recommended: pip install sacremoses."""     )
                 a_     :  Any				      =     lambda lowerCamelCase_     : x

       def     UpperCAmelCase( self   :  List[Any]   ,				lowerCamelCase_   :  str     ):
            return self.punc_normalizer(lowerCamelCase_     ) if x else ""

       def     UpperCAmelCase( self   :  Any   ,				lowerCamelCase_   :  Union[str, Any]     ):
            return self.current_encoder.get(lowerCamelCase_   ,				self.current_encoder[self.unk_token]     )

       def     UpperCAmelCase( self   :  Optional[int]   ,				lowerCamelCase_   :  str     ):
            a_     :  str				      =     self.language_code_re.match(lowerCamelCase_     )
            a_     :  list				      =     [match.group(0     )] if match else []
            return code, self.language_code_re.sub(""""""   ,				lowerCamelCase_     )

       def     UpperCAmelCase( self   :  str   ,				lowerCamelCase_   :  str     ):
            a_      ,      a_     :  str				      =     self.remove_language_code(lowerCamelCase_     )
            a_     :  List[str]				      =     self.current_spm.encode(lowerCamelCase_   ,				out_type=lowerCamelCase_     )
            return code + pieces

       def     UpperCAmelCase( self   :  Dict   ,				lowerCamelCase_   :  int     ):
            return self.decoder.get(lowerCamelCase_   ,				self.unk_token     )

       def     UpperCAmelCase( self   :  str   ,				lowerCamelCase_   :  int   ,				**lowerCamelCase_   :  Tuple     ):
            return super().batch_decode(lowerCamelCase_   ,				**lowerCamelCase_     )

       def     UpperCAmelCase( self   :  Any   ,				lowerCamelCase_   :  str   ,				**lowerCamelCase_   :  Any     ):
            return super().decode(lowerCamelCase_   ,				**lowerCamelCase_     )

       def     UpperCAmelCase( self   :  Any   ,				lowerCamelCase_   :  List[str]     ):
            a_     :  Optional[Any]				      =     self.spm_source if self._decode_use_source_tokenizer else self.spm_target
            a_     :  Optional[Any]				      =     []
            a_     :  str				      =     """"""
            for token in tokens:
                 # make sure that special tokens are not decoded using sentencepiece model
                 if token in self.all_special_tokens:
                      out_string += sp_model.decode_pieces(lowerCamelCase_     ) + token + " "
                      a_     :  Dict				      =     []
                 else:
                      current_sub_tokens.append(lowerCamelCase_     )
            out_string += sp_model.decode_pieces(lowerCamelCase_     )
            return out_string.strip()

       def     UpperCAmelCase( self   :  Union[str, Any]   ,				lowerCamelCase_   :  Union[str, Any]   ,				lowerCamelCase_   :  Any=None     ):
            if token_ids_a is None:
                 return token_ids_a + [self.eos_token_id]
            # We don't expect to process pairs, but leave the pair logic for API consistency
            return token_ids_a + token_ids_a + [self.eos_token_id]

       def     UpperCAmelCase( self   :  Optional[int]     ):
            a_     :  Optional[Any]				      =     self.spm_source
            a_     :  Optional[Any]				      =     self.encoder

       def     UpperCAmelCase( self   :  List[str]     ):
            a_     :  Dict				      =     self.spm_target
            if self.separate_vocabs:
                 a_     :  List[Any]				      =     self.target_encoder

       @property
       def     UpperCAmelCase( self   :  str     ):
            return len(self.encoder     )

       def     UpperCAmelCase( self   :  Optional[int]   ,				lowerCamelCase_   :  str   ,				lowerCamelCase_   :  Optional[str] = None     ):
            if not os.path.isdir(lowerCamelCase_     ):
                 logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''     )
                 return
            a_     :  Tuple				      =     []

            if self.separate_vocabs:
                 a_     :  Optional[Any]				      =     os.path.join(
                     lowerCamelCase_   ,				(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab"""]   ,				)
                 a_     :  List[Any]				      =     os.path.join(
                     lowerCamelCase_   ,				(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""target_vocab_file"""]   ,				)
                 save_json(self.encoder   ,				lowerCamelCase_     )
                 save_json(self.target_encoder   ,				lowerCamelCase_     )
                 saved_files.append(lowerCamelCase_     )
                 saved_files.append(lowerCamelCase_     )
            else:
                 a_     :  Optional[Any]				      =     os.path.join(
                     lowerCamelCase_   ,				(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab"""]     )
                 save_json(self.encoder   ,				lowerCamelCase_     )
                 saved_files.append(lowerCamelCase_     )

            for spm_save_filename, spm_orig_path, spm_model in zip(
                [VOCAB_FILES_NAMES["""source_spm"""], VOCAB_FILES_NAMES["""target_spm"""]]   ,				self.spm_files   ,				[self.spm_source, self.spm_target]   ,				):
                 a_     :  Union[str, Any]				      =     os.path.join(
                     lowerCamelCase_   ,				(filename_prefix + """-""" if filename_prefix else """""") + spm_save_filename     )
                 if os.path.abspath(lowerCamelCase_     ) != os.path.abspath(lowerCamelCase_     ) and os.path.isfile(lowerCamelCase_     ):
                      copyfile(lowerCamelCase_   ,				lowerCamelCase_     )
                      saved_files.append(lowerCamelCase_     )
                 elif not os.path.isfile(lowerCamelCase_     ):
                      with open(lowerCamelCase_   ,				"""wb"""     ) as fi:
                           a_     :  List[str]				      =     spm_model.serialized_model_proto()
                           fi.write(lowerCamelCase_     )
                      saved_files.append(lowerCamelCase_     )

            return tuple(lowerCamelCase_     )

       def     UpperCAmelCase( self   :  Tuple     ):
            return self.get_src_vocab()

       def     UpperCAmelCase( self   :  Optional[Any]     ):
            return dict(self.encoder   ,				**self.added_tokens_encoder     )

       def     UpperCAmelCase( self   :  int     ):
            return dict(self.target_encoder   ,				**self.added_tokens_decoder     )

       def __getstate__( self   :  Optional[Any]     ):
            a_     :  Any				      =     self.__dict__.copy()
            state.update(
                {k: None for k in ["""spm_source""", """spm_target""", """current_spm""", """punc_normalizer""", """target_vocab_file"""]}     )
            return state

       def __setstate__( self   :  Optional[Any]   ,				lowerCamelCase_   :  Dict     ):
            a_     :  List[str]				      =     d

            # for backward compatibility
            if not hasattr(self   ,				"""sp_model_kwargs"""     ):
                 a_     :  str				      =     {}

            a_      ,      a_     :  Optional[int]				      =     (load_spm(lowerCamelCase_   ,				self.sp_model_kwargs     ) for f in self.spm_files)
            a_     :  int				      =     self.spm_source
            self._setup_normalizer()

       def     UpperCAmelCase( self   :  Optional[int]   ,				*lowerCamelCase_   :  str   ,				**lowerCamelCase_   :  int     ):
            return 1

       def     UpperCAmelCase( self   :  Union[str, Any]   ,				lowerCamelCase_   :  List[Any]     ):
            a_     :  Tuple				      =     set(self.all_special_ids     )  # call it once instead of inside list comp
            all_special_ids.remove(self.unk_token_id     )  # <unk> is only sometimes special
            return [1 if x in all_special_ids else 0 for x in seq]

       def     UpperCAmelCase( self   :  List[Any]   ,				lowerCamelCase_   :  List   ,				lowerCamelCase_   :  Optional[List] = None   ,				lowerCamelCase_   :  bool = False     ):
            if already_has_special_tokens:
                 return self._special_token_mask(lowerCamelCase_     )
            elif token_ids_a is None:
                 return self._special_token_mask(lowerCamelCase_     ) + [1]
            else:
                 return self._special_token_mask(token_ids_a + token_ids_a     ) + [1]



def 			_a      (    __UpperCamelCase	,	__UpperCamelCase			):
     a_     :  Dict				      =     sentencepiece.SentencePieceProcessor(**__UpperCamelCase			)
     spm.Load(__UpperCamelCase			)
     return spm



def 			_a      (    __UpperCamelCase	,	__UpperCamelCase			):
     with open(__UpperCamelCase	,	"""w"""			) as f:
          json.dump(__UpperCamelCase	,	__UpperCamelCase	,	indent=2			)



def 			_a      (    __UpperCamelCase			):
     with open(__UpperCamelCase	,	"""r"""			) as f:
          return json.load(__UpperCamelCase			)





'''simple docstring'''
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  UpperCAmelCase_					:





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





 def 							snake_case__		(     self):
     snake_case_			:     str        =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

     snake_case_			:     Tuple        =    None
     if self.use_labels:
         snake_case_			:     Union[str, Any]        =    ids_tensor([self.batch_size]			,							self.type_sequence_label_size)

     snake_case_			:     Any        =    self.get_config()

     return config, pixel_values, labels





 def 							snake_case__		(     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 							snake_case__		(     self			,							lowercase_			,							lowercase_			,							lowercase_):
     snake_case_			:     str        =    DonutSwinModel(config=lowercase_)
     model.to(lowercase_)
     model.eval()
     snake_case_			:     Union[str, Any]        =    model(lowercase_)

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






@require_torch
class  UpperCAmelCase_					(						snake_case__     ,    snake_case__     ,    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 							snake_case__		(     self):
     snake_case_			:     Union[str, Any]        =    DonutSwinModelTester(self)
     snake_case_			:     Optional[Any]        =    ConfigTester(self			,							config_class=lowercase_			,							embed_dim=37)





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





 def 							snake_case__		(     self):
     snake_case_			:     int        =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_)





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





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Tuple        =    self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         snake_case_			:     Any        =    model_class(lowercase_)
         self.assertIsInstance(model.get_input_embeddings()			,							(nn.Module))
         snake_case_			:     List[str]        =    model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(lowercase_			,							nn.Linear))





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Optional[Any]        =    self.model_tester.prepare_config_and_inputs_for_common()

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

         snake_case_			:     Any        =    ["pixel_values"]
         self.assertListEqual(arg_names[:1]			,							lowercase_)





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Union[str, Any]        =    self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_			:     Union[str, Any]        =    True

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

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

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

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

         snake_case_			:     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 							snake_case__		(     self			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_):
     snake_case_			:     Union[str, Any]        =    model_class(lowercase_)
     model.to(lowercase_)
     model.eval()

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

     snake_case_			:     Dict        =    outputs.hidden_states

     snake_case_			:     Dict        =    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
     snake_case_			:     List[Any]        =    (
         config.patch_size
         if isinstance(config.patch_size			,							collections.abc.Iterable)
         else (config.patch_size, config.patch_size)
     )

     snake_case_			:     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]			,							)

     snake_case_			:     str        =    outputs.reshaped_hidden_states
     self.assertEqual(len(lowercase_)			,							lowercase_)

     snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_			:     Dict        =    reshaped_hidden_states[0].shape
     snake_case_			:     Union[str, Any]        =    (
         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 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     int        =    self.model_tester.prepare_config_and_inputs_for_common()

     snake_case_			:     Union[str, Any]        =    (
         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:
         snake_case_			:     List[str]        =    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"]
         snake_case_			:     List[Any]        =    True

         self.check_hidden_states_output(lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     List[str]        =    self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_			:     Any        =    3

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

     snake_case_			:     str        =    image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
     snake_case_			:     List[str]        =    image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

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





 @slow
 def 							snake_case__		(     self):
     for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         snake_case_			:     List[str]        =    DonutSwinModel.from_pretrained(lowercase_)
         self.assertIsNotNone(lowercase_)





 def 							snake_case__		(     self):
     snake_case_      ,			snake_case_			:     Union[str, Any]        =    self.model_tester.prepare_config_and_inputs_for_common()

     snake_case_			:     Dict        =    _config_zero_init(lowercase_)
     for model_class in self.all_model_classes:
         snake_case_			:     str        =    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'			,							)




