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   :    Union[str, Any]     ,       lowercase__   :    Optional[int]     ,       lowercase__   :    Optional[Any]=13     ,       lowercase__   :    List[str]=32     ,       lowercase__   :    Optional[Any]=2     ,       lowercase__   :    Optional[int]=3     ,       lowercase__   :    List[str]=16     ,       lowercase__   :    List[str]=[1, 2, 1]     ,       lowercase__   :    Dict=[2, 2, 4]     ,       lowercase__   :    Any=2     ,       lowercase__   :    Union[str, Any]=2.0     ,       lowercase__   :    str=True     ,       lowercase__   :    str=0.0     ,       lowercase__   :    Tuple=0.0     ,       lowercase__   :    Dict=0.1     ,       lowercase__   :    Union[str, Any]="gelu"     ,       lowercase__   :    Union[str, Any]=False     ,       lowercase__   :    List[str]=True     ,       lowercase__   :    Optional[int]=0.02     ,       lowercase__   :    Tuple=1e-5     ,       lowercase__   :    Any=True     ,       lowercase__   :    Union[str, Any]=None     ,       lowercase__   :    Optional[Any]=True     ,       lowercase__   :    str=10     ,       lowercase__   :    str=8     ,       ):







        '''simple docstring'''



        lowerCAmelCase__	      =   parent
        lowerCAmelCase__	      =   batch_size
        lowerCAmelCase__	      =   image_size
        lowerCAmelCase__	      =   patch_size
        lowerCAmelCase__	      =   num_channels
        lowerCAmelCase__	      =   embed_dim
        lowerCAmelCase__	      =   depths
        lowerCAmelCase__	      =   num_heads
        lowerCAmelCase__	      =   window_size
        lowerCAmelCase__	      =   mlp_ratio
        lowerCAmelCase__	      =   qkv_bias
        lowerCAmelCase__	      =   hidden_dropout_prob
        lowerCAmelCase__	      =   attention_probs_dropout_prob
        lowerCAmelCase__	      =   drop_path_rate
        lowerCAmelCase__	      =   hidden_act
        lowerCAmelCase__	      =   use_absolute_embeddings
        lowerCAmelCase__	      =   patch_norm
        lowerCAmelCase__	      =   layer_norm_eps
        lowerCAmelCase__	      =   initializer_range
        lowerCAmelCase__	      =   is_training
        lowerCAmelCase__	      =   scope
        lowerCAmelCase__	      =   use_labels
        lowerCAmelCase__	      =   type_sequence_label_size
        lowerCAmelCase__	      =   encoder_stride




 def 						__snake_case		(     self   :    Union[str, Any]):







        '''simple docstring'''



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

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

        lowerCAmelCase__	      =   self.get_config()

        return config, pixel_values, labels




 def 						__snake_case		(     self   :    Optional[Any]):







        '''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 						__snake_case		(     self   :    List[Any]     ,       lowercase__   :    str     ,       lowercase__   :    Optional[int]     ,       lowercase__   :    List[str]):







        '''simple docstring'''



        lowerCAmelCase__	      =   DonutSwinModel(config=lowercase__)
        model.to(lowercase__)
        model.eval()
        lowerCAmelCase__	      =   model(lowercase__)

        lowerCAmelCase__	      =   ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1))
        lowerCAmelCase__	      =   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   :    Union[str, Any]):







        '''simple docstring'''



        lowerCAmelCase__	      =   self.prepare_config_and_inputs()
        (
            lowerCAmelCase__			
        )	      =   config_and_inputs
        lowerCAmelCase__	      =   {"""pixel_values""": pixel_values}
        return config, inputs_dict






@require_torch
class 							a_					(		_lowerCAmelCase			,	_lowerCAmelCase			,	unittest.TestCase		):






 '''simple docstring'''






 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   :    List[str]):







        '''simple docstring'''



        lowerCAmelCase__	      =   DonutSwinModelTester(self)
        lowerCAmelCase__	      =   ConfigTester(self     ,       config_class=lowercase__     ,       embed_dim=37)




 def 						__snake_case		(     self   :    List[Any]):







        '''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 						__snake_case		(     self   :    str):







        '''simple docstring'''



        return




 def 						__snake_case		(     self   :    Tuple):







        '''simple docstring'''



        lowerCAmelCase__	      =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowercase__)




 def 						__snake_case		(     self   :    Tuple):







        '''simple docstring'''



        pass




 def 						__snake_case		(     self   :    int):







        '''simple docstring'''



        lowerCAmelCase__	      =   self.model_tester.prepare_config_and_inputs_for_common()

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




 def 						__snake_case		(     self   :    List[str]):







        '''simple docstring'''



        lowerCAmelCase__	      =   self.model_tester.prepare_config_and_inputs_for_common()

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

               lowerCAmelCase__	      =   ["""pixel_values"""]
               self.assertListEqual(arg_names[:1]     ,       lowercase__)




 def 						__snake_case		(     self   :    str):







        '''simple docstring'''



        lowerCAmelCase__	      =   self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase__	      =   True

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

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

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

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

               lowerCAmelCase__	      =   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   :    Optional[int]     ,       lowercase__   :    int     ,       lowercase__   :    Optional[int]     ,       lowercase__   :    str     ,       lowercase__   :    Union[str, Any]):







        '''simple docstring'''



        lowerCAmelCase__	      =   model_class(lowercase__)
        model.to(lowercase__)
        model.eval()

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

        lowerCAmelCase__	      =   outputs.hidden_states

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

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

        lowerCAmelCase__	      =   reshaped_hidden_states[0].shape
        lowerCAmelCase__	      =   (
            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   :    Any):







        '''simple docstring'''



        lowerCAmelCase__	      =   self.model_tester.prepare_config_and_inputs_for_common()

        lowerCAmelCase__	      =   (
            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__	      =   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__	      =   True

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




 def 						__snake_case		(     self   :    str):







        '''simple docstring'''



        lowerCAmelCase__	      =   self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase__	      =   3

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

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

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




 @slow
 def 						__snake_case		(     self   :    Optional[int]):







        '''simple docstring'''



        for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowerCAmelCase__	      =   DonutSwinModel.from_pretrained(lowercase__)
               self.assertIsNotNone(lowercase__)




 def 						__snake_case		(     self   :    Tuple):







        '''simple docstring'''



        lowerCAmelCase__	      =   self.model_tester.prepare_config_and_inputs_for_common()

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





"""simple docstring"""
import argparse
import copy
import json
import multiprocessing
import os
import time

from create_dummy_models import COMPOSITE_MODELS, create_tiny_models
from huggingface_hub import ModelFilter, hf_api

import transformers
from transformers import AutoFeatureExtractor, AutoImageProcessor, AutoTokenizer
from transformers.image_processing_utils import BaseImageProcessor
def   A_    (     ):







						'''simple docstring'''


						snake_case_					:Any		=     set()
						# Each auto modeling files contains multiple mappings. Let's get them in a dynamic way.
						for module_name in ["modeling_auto", "modeling_tf_auto", "modeling_flax_auto"]:
												snake_case_					:Union[str, Any]		=     getattr(transformers.models.auto,   _lowercase,   _lowercase      )
												if module is None:
																		continue
												# all mappings in a single auto modeling file
												snake_case_					:int		=     [
												    x
												    for x in dir(_lowercase      )
												    if x.endswith("""_MAPPING_NAMES"""      )
												    and (x.startswith("""MODEL_"""      ) or x.startswith("""TF_MODEL_"""      ) or x.startswith("""FLAX_MODEL_"""      ))
												]
												for name in mapping_names:
																		snake_case_					:Tuple		=     getattr(_lowercase,   _lowercase      )
																		if mapping is not None:
																								for v in mapping.values():
																														if isinstance(_lowercase,   (list, tuple)      ):
																																				model_names.update(_lowercase      )
																														elif isinstance(_lowercase,   _lowercase      ):
																																				model_names.add(_lowercase      )

						return sorted(_lowercase      )
def   A_    (     ):







						'''simple docstring'''


						snake_case_					:List[str]		=     set(get_all_model_names()      )

						with open("""tests/utils/tiny_model_summary.json"""      ) as fp:
												snake_case_					:Any		=     json.load(_lowercase      )
						snake_case_					:Any		=     set()
						for model_base_name in tiny_model_info:
												tiny_models_names.update(tiny_model_info[model_base_name]["""model_classes"""]      )

						# Remove a tiny model name if one of its framework implementation hasn't yet a tiny version on the Hub.
						snake_case_					:Any		=     model_names.difference(_lowercase      )
						for model_name in copy.copy(_lowercase      ):
												if not model_name.startswith("""TF"""      ) and f"""TF{model_name}""" in not_on_hub:
																		tiny_models_names.remove(_lowercase      )
												elif model_name.startswith("""TF"""      ) and model_name[2:] in not_on_hub:
																		tiny_models_names.remove(_lowercase      )

						return sorted(_lowercase      )
def   A_    (     _lowercase      ):







						'''simple docstring'''


						snake_case_					:Tuple		=     COMPOSITE_MODELS.values()

						# All tiny model base names on Hub
						snake_case_					:Any		=     get_all_model_names()
						snake_case_					:Dict		=     hf_api.list_models(
						    filter=ModelFilter(
						        author="""hf-internal-testing""",   )      )
						snake_case_					:List[Any]		=     set()
						for x in models:
												snake_case_					:List[Any]		=     x.modelId
												snake_case_,			snake_case_					:Tuple		=     model.split("""/"""      )
												if not model.startswith("""tiny-random-"""      ):
																		continue
												snake_case_					:str		=     model.replace("""tiny-random-""",   """"""      )
												if not model[0].isupper():
																		continue
												if model not in model_names and model not in special_models:
																		continue
												_models.add(_lowercase      )

						snake_case_					:List[str]		=     sorted(_models      )
						# All tiny model names on Hub
						snake_case_					:List[str]		=     {}
						for model in models:
												snake_case_					:List[Any]		=     f"""hf-internal-testing/tiny-random-{model}"""
												snake_case_					:int		=     model.split("""-"""      )[0]
												try:
																		snake_case_					:List[Any]		=     hf_api.repo_info(_lowercase      )
																		snake_case_					:Optional[Any]		=     {
																		    """tokenizer_classes""": set(),
																		    """processor_classes""": set(),
																		    """model_classes""": set(),
																		    """sha""": repo_info.sha,
																		}
												except Exception:
																		continue
												try:
																		time.sleep(1      )
																		snake_case_					:Optional[Any]		=     AutoTokenizer.from_pretrained(_lowercase      )
																		content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:Union[str, Any]		=     AutoTokenizer.from_pretrained(_lowercase,   use_fast=_lowercase      )
																		content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:Any		=     AutoImageProcessor.from_pretrained(_lowercase      )
																		content["processor_classes"].add(img_p.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:List[Any]		=     AutoFeatureExtractor.from_pretrained(_lowercase      )
																		if not isinstance(_lowercase,   _lowercase      ):
																								content["processor_classes"].add(feat_p.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:str		=     getattr(_lowercase,   _lowercase      )
																		snake_case_					:Tuple		=     model_class.from_pretrained(_lowercase      )
																		content["model_classes"].add(m.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:List[Any]		=     getattr(_lowercase,   f"""TF{model}"""      )
																		snake_case_					:List[str]		=     model_class.from_pretrained(_lowercase      )
																		content["model_classes"].add(m.__class__.__name__      )
												except Exception:
																		pass

												snake_case_					:Union[str, Any]		=     sorted(content["""tokenizer_classes"""]      )
												snake_case_					:Dict		=     sorted(content["""processor_classes"""]      )
												snake_case_					:List[str]		=     sorted(content["""model_classes"""]      )

												snake_case_					:Tuple		=     content
												with open(os.path.join(_lowercase,   """hub_tiny_model_summary.json"""      ),   """w"""      ) as fp:
																		json.dump(_lowercase,   _lowercase,   ensure_ascii=_lowercase,   indent=4      )


if __name__ == "__main__":
						__a           =							argparse.ArgumentParser()
						parser.add_argument("--num_workers", default=1, type=int, help="The number of workers to run.")
						__a           =							parser.parse_args()

						# This has to be `spawn` to avoid hanging forever!
						multiprocessing.set_start_method("spawn")

						__a           =							"tiny_models"
						__a           =							True
						__a           =							None
						__a           =							get_tiny_model_names_from_repo()
						__a           =							True
						__a           =							True
						__a           =							"hf-internal-testing"

						create_tiny_models(
						    output_path,
						    all,
						    model_types,
						    models_to_skip,
						    no_check,
						    upload,
						    organization,
						    token=os.environ.get("TOKEN", None),
						    num_workers=args.num_workers,
						)
