





"""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 	__lowerCamelCase       :





		'''simple docstring'''






		def __init__(     self							:			List[str]		,    a_							:			Tuple		,    a_							:			Any=13		,    a_							:			Dict=32		,    a_							:			Optional[Any]=2		,    a_							:			Dict=3		,    a_							:			int=16		,    a_							:			Tuple=[1, 2, 1]		,    a_							:			List[str]=[2, 2, 4]		,    a_							:			Union[str, Any]=2		,    a_							:			Optional[Any]=2.0		,    a_							:			Optional[int]=True		,    a_							:			Dict=0.0		,    a_							:			List[Any]=0.0		,    a_							:			Tuple=0.1		,    a_							:			int="gelu"		,    a_							:			str=False		,    a_							:			int=True		,    a_							:			Optional[Any]=0.02		,    a_							:			List[Any]=1e-5		,    a_							:			Any=True		,    a_							:			int=None		,    a_							:			List[Any]=True		,    a_							:			int=10		,    a_							:			Optional[Any]=8		,    ):
				lowerCAmelCase_     :							Optional[int]             =    parent
				lowerCAmelCase_     :							int             =    batch_size
				lowerCAmelCase_     :							Any             =    image_size
				lowerCAmelCase_     :							int             =    patch_size
				lowerCAmelCase_     :							Union[str, Any]             =    num_channels
				lowerCAmelCase_     :							Dict             =    embed_dim
				lowerCAmelCase_     :							Dict             =    depths
				lowerCAmelCase_     :							Any             =    num_heads
				lowerCAmelCase_     :							int             =    window_size
				lowerCAmelCase_     :							Optional[int]             =    mlp_ratio
				lowerCAmelCase_     :							List[Any]             =    qkv_bias
				lowerCAmelCase_     :							str             =    hidden_dropout_prob
				lowerCAmelCase_     :							int             =    attention_probs_dropout_prob
				lowerCAmelCase_     :							str             =    drop_path_rate
				lowerCAmelCase_     :							Dict             =    hidden_act
				lowerCAmelCase_     :							Any             =    use_absolute_embeddings
				lowerCAmelCase_     :							Optional[int]             =    patch_norm
				lowerCAmelCase_     :							Tuple             =    layer_norm_eps
				lowerCAmelCase_     :							Any             =    initializer_range
				lowerCAmelCase_     :							Optional[int]             =    is_training
				lowerCAmelCase_     :							Union[str, Any]             =    scope
				lowerCAmelCase_     :							List[Any]             =    use_labels
				lowerCAmelCase_     :							Optional[Any]             =    type_sequence_label_size
				lowerCAmelCase_     :							int             =    encoder_stride





		def      lowerCamelCase (     self							:			Dict			):
				lowerCAmelCase_     :							Tuple             =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

				lowerCAmelCase_     :							str             =    self.get_config()

				return config, pixel_values, labels





		def      lowerCamelCase (     self							:			Dict			):
				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							:			Optional[Any]		,    a_							:			List[Any]		,    a_							:			Dict		,    a_							:			List[str]			):
				lowerCAmelCase_     :							Union[str, Any]             =    DonutSwinModel(config=a_			)
				model.to(a_			)
				model.eval()
				lowerCAmelCase_     :							List[Any]             =    model(a_			)

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







@require_torch
class 	__lowerCamelCase       (				A__				,							A__				,							unittest.TestCase    ):





		'''simple docstring'''






		a_			:       List[Any]      =							(DonutSwinModel,) if is_torch_available() else ()
		a_			:       str      =							{"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
		a_			:       List[str]      =							True

		a_			:       Union[str, Any]      =							False
		a_			:       Optional[Any]      =							False
		a_			:       Optional[Any]      =							False





		def      lowerCamelCase (     self							:			Optional[int]			):
				lowerCAmelCase_     :							Dict             =    DonutSwinModelTester(self			)
				lowerCAmelCase_     :							str             =    ConfigTester(self		,    config_class=a_		,    embed_dim=37			)





		def      lowerCamelCase (     self							:			Dict			):
				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							:			List[str]			):
				lowerCAmelCase_     :							Dict             =    self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*a_			)





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





		def      lowerCamelCase (     self							:			Tuple			):
				lowerCAmelCase_     :							Optional[Any]             =    self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						lowerCAmelCase_     :							Optional[Any]             =    model_class(a_			)
						self.assertIsInstance(model.get_input_embeddings()		,    (nn.Module)			)
						lowerCAmelCase_     :							Dict             =    model.get_output_embeddings()
						self.assertTrue(x is None or isinstance(a_		,    nn.Linear			)			)





		def      lowerCamelCase (     self							:			int			):
				lowerCAmelCase_     :							int             =    self.model_tester.prepare_config_and_inputs_for_common()

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

						lowerCAmelCase_     :							Union[str, Any]             =    ["pixel_values"]
						self.assertListEqual(arg_names[:1]		,    a_			)





		def      lowerCamelCase (     self							:			Dict			):
				lowerCAmelCase_     :							Any             =    self.model_tester.prepare_config_and_inputs_for_common()
				lowerCAmelCase_     :							Union[str, Any]             =    True

				for model_class in self.all_model_classes:
						lowerCAmelCase_     :							Any             =    True
						lowerCAmelCase_     :							Optional[Any]             =    False
						lowerCAmelCase_     :							Any             =    True
						lowerCAmelCase_     :							int             =    model_class(a_			)
						model.to(a_			)
						model.eval()
						with torch.no_grad():
								lowerCAmelCase_     :							Any             =    model(**self._prepare_for_class(a_		,    a_			)			)
						lowerCAmelCase_     :							Any             =    outputs.attentions
						lowerCAmelCase_     :							int             =    len(self.model_tester.depths			)
						self.assertEqual(len(a_			)		,    a_			)

						# check that output_attentions also work using config
						del inputs_dict["output_attentions"]
						lowerCAmelCase_     :							Any             =    True
						lowerCAmelCase_     :							Union[str, Any]             =    config.window_size**2
						lowerCAmelCase_     :							Dict             =    model_class(a_			)
						model.to(a_			)
						model.eval()
						with torch.no_grad():
								lowerCAmelCase_     :							Union[str, Any]             =    model(**self._prepare_for_class(a_		,    a_			)			)
						lowerCAmelCase_     :							Tuple             =    outputs.attentions
						self.assertEqual(len(a_			)		,    a_			)

						self.assertListEqual(
						    list(attentions[0].shape[-3:]			)		,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,    )
						lowerCAmelCase_     :							Union[str, Any]             =    len(a_			)

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

						if hasattr(self.model_tester		,    "num_hidden_states_types"			):
								lowerCAmelCase_     :							Optional[Any]             =    self.model_tester.num_hidden_states_types
						else:
								# also another +1 for reshaped_hidden_states
								lowerCAmelCase_     :							Union[str, Any]             =    2
						self.assertEqual(out_len + added_hidden_states		,    len(a_			)			)

						lowerCAmelCase_     :							List[Any]             =    outputs.attentions

						self.assertEqual(len(a_			)		,    a_			)

						self.assertListEqual(
						    list(self_attentions[0].shape[-3:]			)		,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,    )





		def      lowerCamelCase (     self							:			int		,    a_							:			Optional[int]		,    a_							:			str		,    a_							:			Union[str, Any]		,    a_							:			Dict			):
				lowerCAmelCase_     :							List[Any]             =    model_class(a_			)
				model.to(a_			)
				model.eval()

				with torch.no_grad():
						lowerCAmelCase_     :							Optional[Any]             =    model(**self._prepare_for_class(a_		,    a_			)			)

				lowerCAmelCase_     :							Tuple             =    outputs.hidden_states

				lowerCAmelCase_     :							str             =    getattr(
				    self.model_tester		,    "expected_num_hidden_layers"		,    len(self.model_tester.depths			) + 1			)
				self.assertEqual(len(a_			)		,    a_			)

				# DonutSwin has a different seq_length
				lowerCAmelCase_     :							Optional[int]             =    (
				    config.patch_size
				    if isinstance(config.patch_size		,    collections.abc.Iterable			)
				    else (config.patch_size, config.patch_size)
				)

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

				lowerCAmelCase_     :							Dict             =    outputs.reshaped_hidden_states
				self.assertEqual(len(a_			)		,    a_			)

				lowerCAmelCase_     :							Dict             =    reshaped_hidden_states[0].shape
				lowerCAmelCase_     :							List[str]             =    (
				    reshaped_hidden_states[0].view(a_		,    a_		,    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			):
				lowerCAmelCase_     :							int             =    self.model_tester.prepare_config_and_inputs_for_common()

				lowerCAmelCase_     :							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)
				)

				for model_class in self.all_model_classes:
						lowerCAmelCase_     :							Any             =    True
						self.check_hidden_states_output(a_		,    a_		,    a_		,    a_			)

						# check that output_hidden_states also work using config
						del inputs_dict["output_hidden_states"]
						lowerCAmelCase_     :							Optional[Any]             =    True

						self.check_hidden_states_output(a_		,    a_		,    a_		,    a_			)





		def      lowerCamelCase (     self							:			Optional[Any]			):
				lowerCAmelCase_     :							Dict             =    self.model_tester.prepare_config_and_inputs_for_common()
				lowerCAmelCase_     :							int             =    3

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

				lowerCAmelCase_     :							int             =    image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
				lowerCAmelCase_     :							Any             =    image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

				for model_class in self.all_model_classes:
						lowerCAmelCase_     :							Tuple             =    True
						self.check_hidden_states_output(a_		,    a_		,    a_		,    (padded_height, padded_width)			)

						# check that output_hidden_states also work using config
						del inputs_dict["output_hidden_states"]
						lowerCAmelCase_     :							int             =    True
						self.check_hidden_states_output(a_		,    a_		,    a_		,    (padded_height, padded_width)			)





		@slow
		def      lowerCamelCase (     self							:			str			):
				for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowerCAmelCase_     :							List[str]             =    DonutSwinModel.from_pretrained(a_			)
						self.assertIsNotNone(a_			)





		def      lowerCamelCase (     self							:			str			):
				lowerCAmelCase_     :							Optional[int]             =    self.model_tester.prepare_config_and_inputs_for_common()

				lowerCAmelCase_     :							Union[str, Any]             =    _config_zero_init(a_			)
				for model_class in self.all_model_classes:
						lowerCAmelCase_     :							Union[str, Any]             =    model_class(config=a_			)
						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"""

from .pipeline_kandinskya_a import KandinskyVaaPipeline
from .pipeline_kandinsky2_2_controlnet import KandinskyVaaControlnetPipeline
from .pipeline_kandinsky2_2_controlnet_img2img import KandinskyVaaControlnetImgaImgPipeline
from .pipeline_kandinsky2_2_img2img import KandinskyVaaImgaImgPipeline
from .pipeline_kandinsky2_2_inpainting import KandinskyVaaInpaintPipeline
from .pipeline_kandinsky2_2_prior import KandinskyVaaPriorPipeline
from .pipeline_kandinsky2_2_prior_emb2emb import KandinskyVaaPriorEmbaEmbPipeline
