

import importlib
import inspect
import json
import os
from collections import OrderedDict

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...image_processing_utils import ImageProcessingMixin
from ...tokenization_utils import TOKENIZER_CONFIG_FILE
from ...utils import FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)
from .feature_extraction_auto import AutoFeatureExtractor
from .image_processing_auto import AutoImageProcessor
from .tokenization_auto import AutoTokenizer


SCREAMING_SNAKE_CASE						:Union[str, Any]      =			logging.get_logger(__name__)

SCREAMING_SNAKE_CASE						:List[str]      =			OrderedDict(
    [
        ("""align""", """AlignProcessor"""),
        ("""altclip""", """AltCLIPProcessor"""),
        ("""bark""", """BarkProcessor"""),
        ("""blip""", """BlipProcessor"""),
        ("""blip-2""", """Blip2Processor"""),
        ("""bridgetower""", """BridgeTowerProcessor"""),
        ("""chinese_clip""", """ChineseCLIPProcessor"""),
        ("""clap""", """ClapProcessor"""),
        ("""clip""", """CLIPProcessor"""),
        ("""clipseg""", """CLIPSegProcessor"""),
        ("""flava""", """FlavaProcessor"""),
        ("""git""", """GitProcessor"""),
        ("""groupvit""", """CLIPProcessor"""),
        ("""hubert""", """Wav2Vec2Processor"""),
        ("""instructblip""", """InstructBlipProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2Processor"""),
        ("""layoutlmv3""", """LayoutLMv3Processor"""),
        ("""markuplm""", """MarkupLMProcessor"""),
        ("""mctct""", """MCTCTProcessor"""),
        ("""mgp-str""", """MgpstrProcessor"""),
        ("""oneformer""", """OneFormerProcessor"""),
        ("""owlvit""", """OwlViTProcessor"""),
        ("""pix2struct""", """Pix2StructProcessor"""),
        ("""sam""", """SamProcessor"""),
        ("""sew""", """Wav2Vec2Processor"""),
        ("""sew-d""", """Wav2Vec2Processor"""),
        ("""speech_to_text""", """Speech2TextProcessor"""),
        ("""speech_to_text_2""", """Speech2Text2Processor"""),
        ("""speecht5""", """SpeechT5Processor"""),
        ("""trocr""", """TrOCRProcessor"""),
        ("""tvlt""", """TvltProcessor"""),
        ("""unispeech""", """Wav2Vec2Processor"""),
        ("""unispeech-sat""", """Wav2Vec2Processor"""),
        ("""vilt""", """ViltProcessor"""),
        ("""vision-text-dual-encoder""", """VisionTextDualEncoderProcessor"""),
        ("""wav2vec2""", """Wav2Vec2Processor"""),
        ("""wav2vec2-conformer""", """Wav2Vec2Processor"""),
        ("""wavlm""", """Wav2Vec2Processor"""),
        ("""whisper""", """WhisperProcessor"""),
        ("""xclip""", """XCLIPProcessor"""),
    ]
)

SCREAMING_SNAKE_CASE						:List[Any]      =			_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)




def        lowerCAmelCase(	SCREAMING_SNAKE_CASE_       )->		Dict:



    """simple docstring"""






    for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
        if class_name in processors:
            UpperCamelCase_          =		model_type_to_module_name(SCREAMING_SNAKE_CASE_       )

            UpperCamelCase_          =		importlib.import_module(f".{module_name}"       ,		"transformers.models"       )
            try:
                return getattr(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )
            except AttributeError:
                continue

    for processor in PROCESSOR_MAPPING._extra_content.values():
        if getattr(SCREAMING_SNAKE_CASE_       ,		"__name__"       ,		SCREAMING_SNAKE_CASE_       ) == class_name:
            return processor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
    UpperCamelCase_          =		importlib.import_module("transformers"       )
    if hasattr(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ):
        return getattr(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )

    return None






class 		__magic_name__ :






     def __init__(							self     )->			Union[str, Any]:
         raise EnvironmentError(
             "AutoProcessor is designed to be instantiated "
             "using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method."     )






     @classmethod
     @replace_list_option_in_docstrings(_lowercase     )
     def      UpperCAmelCase_							(							cls						,		_lowercase						,		**_lowercase     )->			Any:
         UpperCamelCase_          =		kwargs.pop("config"						,		_lowercase     )
         UpperCamelCase_          =		kwargs.pop("trust_remote_code"						,		_lowercase     )
         UpperCamelCase_          =		True

         UpperCamelCase_          =		None
         UpperCamelCase_          =		None

         # First, let's see if we have a preprocessor config.
         # Filter the kwargs for `get_file_from_repo`.
         UpperCamelCase_          =		{
             key: kwargs[key] for key in inspect.signature(_lowercase     ).parameters.keys() if key in kwargs
         }
         # Let's start by checking whether the processor class is saved in an image processor
         UpperCamelCase_          =		get_file_from_repo(
             _lowercase						,		_lowercase						,		**_lowercase     )
         if preprocessor_config_file is not None:
             UpperCamelCase_   ,    UpperCamelCase_          =		ImageProcessingMixin.get_image_processor_dict(_lowercase						,		**_lowercase     )
             UpperCamelCase_          =		config_dict.get("processor_class"						,		_lowercase     )
             if "AutoProcessor" in config_dict.get("auto_map"						,		{}     ):
                 UpperCamelCase_          =		config_dict["auto_map"]["AutoProcessor"]

        # If not found, let's check whether the processor class is saved in a feature extractor config
         if preprocessor_config_file is not None and processor_class is None:
             UpperCamelCase_   ,    UpperCamelCase_          =		FeatureExtractionMixin.get_feature_extractor_dict(_lowercase						,		**_lowercase     )
             UpperCamelCase_          =		config_dict.get("processor_class"						,		_lowercase     )
             if "AutoProcessor" in config_dict.get("auto_map"						,		{}     ):
                 UpperCamelCase_          =		config_dict["auto_map"]["AutoProcessor"]

         if processor_class is None:
             # Next, let's check whether the processor class is saved in a tokenizer
             UpperCamelCase_          =		get_file_from_repo(
                 _lowercase						,		_lowercase						,		**_lowercase     )
             if tokenizer_config_file is not None:
                 with open(_lowercase						,		encoding="utf-8"     ) as reader:
                     UpperCamelCase_          =		json.load(_lowercase     )

                 UpperCamelCase_          =		config_dict.get("processor_class"						,		_lowercase     )
                 if "AutoProcessor" in config_dict.get("auto_map"						,		{}     ):
                     UpperCamelCase_          =		config_dict["auto_map"]["AutoProcessor"]

         if processor_class is None:
             # Otherwise, load config, if it can be loaded.
             if not isinstance(_lowercase						,		_lowercase     ):
                 UpperCamelCase_          =		AutoConfig.from_pretrained(
                     _lowercase						,		trust_remote_code=_lowercase						,		**_lowercase     )

             # And check if the config contains the processor class.
             UpperCamelCase_          =		getattr(_lowercase						,		"processor_class"						,		_lowercase     )
             if hasattr(_lowercase						,		"auto_map"     ) and "AutoProcessor" in config.auto_map:
                 UpperCamelCase_          =		config.auto_map["AutoProcessor"]

         if processor_class is not None:
             UpperCamelCase_          =		processor_class_from_name(_lowercase     )

         UpperCamelCase_          =		processor_auto_map is not None
         UpperCamelCase_          =		processor_class is not None or type(_lowercase     ) in PROCESSOR_MAPPING
         UpperCamelCase_          =		resolve_trust_remote_code(
             _lowercase						,		_lowercase						,		_lowercase						,		_lowercase     )

         if has_remote_code and trust_remote_code:
             UpperCamelCase_          =		get_class_from_dynamic_module(
                 _lowercase						,		_lowercase						,		**_lowercase     )
             UpperCamelCase_          =		kwargs.pop("code_revision"						,		_lowercase     )
             if os.path.isdir(_lowercase     ):
                 processor_class.register_for_auto_class()
             return processor_class.from_pretrained(
                 _lowercase						,		trust_remote_code=_lowercase						,		**_lowercase     )
         elif processor_class is not None:
             return processor_class.from_pretrained(
                 _lowercase						,		trust_remote_code=_lowercase						,		**_lowercase     )
         # Last try: we use the PROCESSOR_MAPPING.
         elif type(_lowercase     ) in PROCESSOR_MAPPING:
             return PROCESSOR_MAPPING[type(_lowercase     )].from_pretrained(_lowercase						,		**_lowercase     )

         # At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
         # tokenizer.
         try:
             return AutoTokenizer.from_pretrained(
                 _lowercase						,		trust_remote_code=_lowercase						,		**_lowercase     )
         except Exception:
             try:
                 return AutoImageProcessor.from_pretrained(
                     _lowercase						,		trust_remote_code=_lowercase						,		**_lowercase     )
             except Exception:
                 pass

             try:
                 return AutoFeatureExtractor.from_pretrained(
                     _lowercase						,		trust_remote_code=_lowercase						,		**_lowercase     )
             except Exception:
                 pass

         raise ValueError(
             F"Unrecognized processing class in {pretrained_model_name_or_path}. Can't instantiate a processor, a "
             "tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains"
             "the files of at least one of those processing classes."     )






     @staticmethod
     def      UpperCAmelCase_							(							_lowercase						,		_lowercase     )->			Optional[Any]:
         PROCESSOR_MAPPING.register(_lowercase						,		_lowercase     )



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






     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						,		)->			Tuple:
         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      UpperCAmelCase_							(							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      UpperCAmelCase_							(							self     )->			Union[str, 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      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase						,		_lowercase     )->			Optional[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      UpperCAmelCase_							(							self     )->			Tuple:
         UpperCamelCase_          =		self.prepare_config_and_inputs()
         (
             (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    
         )          =		config_and_inputs
         UpperCamelCase_          =		{"pixel_values": pixel_values}
         return config, inputs_dict






@require_torch
class 		__magic_name__ (				snake_case       ,	snake_case       ,	unittest.TestCase							):
     UpperCamelCase_     :List[str]									=	(DonutSwinModel,) if is_torch_available() else ()
     UpperCamelCase_     :Optional[Any]									=	{"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
     UpperCamelCase_     :Any									=	True

     UpperCamelCase_     :Tuple									=	False
     UpperCamelCase_     :List[str]									=	False
     UpperCamelCase_     :List[str]									=	False






     def      UpperCAmelCase_							(							self     )->			Union[str, Any]:
         UpperCamelCase_          =		DonutSwinModelTester(self     )
         UpperCamelCase_          =		ConfigTester(self						,		config_class=_lowercase						,		embed_dim=37     )






     def      UpperCAmelCase_							(							self     )->			Optional[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      UpperCAmelCase_							(							self     )->			Optional[int]:
         return






     def      UpperCAmelCase_							(							self     )->			Tuple:
         UpperCamelCase_          =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowercase     )






     def      UpperCAmelCase_							(							self     )->			int:
         # DonutSwin does not use inputs_embeds
         pass






     def      UpperCAmelCase_							(							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      UpperCAmelCase_							(							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     )
             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      UpperCAmelCase_							(							self     )->			List[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      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase     )->			List[Any]:
         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      UpperCAmelCase_							(							self     )->			List[str]:
         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      UpperCAmelCase_							(							self     )->			Any:
         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      UpperCAmelCase_							(							self     )->			List[str]:
         for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase_          =		DonutSwinModel.from_pretrained(_lowercase     )
             self.assertIsNotNone(_lowercase     )






     def      UpperCAmelCase_							(							self     )->			Any:
         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"						,		)
