
"""simple docstring"""




import colorsys
import io

import cva
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import torch
from matplotlib.backends.backend_agg import FigureCanvasAgg

from utils import img_tensorize


UpperCAmelCase__				:   Tuple   							=			1_0_0_0



class      lowerCAmelCase_						:


				"""simple docstring"""



				def __init__(self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__=1.2       ,	SCREAMING_SNAKE_CASE__="g"       ,	SCREAMING_SNAKE_CASE__=0.5       ,	SCREAMING_SNAKE_CASE__="-"       ,	SCREAMING_SNAKE_CASE__="test_out.jpg"       ,	SCREAMING_SNAKE_CASE__=True       ,	SCREAMING_SNAKE_CASE__=False       ,	SCREAMING_SNAKE_CASE__=None       ,	SCREAMING_SNAKE_CASE__=None       ,	SCREAMING_SNAKE_CASE__=0.7       ,	):



											"""simple docstring"""




											if isinstance(UpperCamelCase__       ,	torch.Tensor   ):
																		SCREAMING_SNAKE_CASE__						:	Optional[int]									=       img.numpy().astype("""np.uint8"""   )
											if isinstance(UpperCamelCase__       ,	UpperCamelCase__   ):
																		SCREAMING_SNAKE_CASE__						:	Any									=       img_tensorize(UpperCamelCase__   )
											assert isinstance(UpperCamelCase__       ,	np.ndarray   )

											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Any									=       img.shape[1], img.shape[0]
											SCREAMING_SNAKE_CASE__						:	int									=       mplfigure.Figure(frameon=UpperCamelCase__   )
											SCREAMING_SNAKE_CASE__						:	List[Any]									=       fig.get_dpi()
											SCREAMING_SNAKE_CASE__						:	Tuple									=       (width * scale + 1E-2) / dpi
											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       (height * scale + 1E-2) / dpi
											fig.set_size_inches(UpperCamelCase__       ,	UpperCamelCase__   )
											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       fig.add_axes([0.0, 0.0, 1.0, 1.0]   )
											ax.axis("""off"""   )
											ax.set_xlim(0.0       ,	UpperCamelCase__   )
											ax.set_ylim(UpperCamelCase__   )

											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       saveas
											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       rgb
											SCREAMING_SNAKE_CASE__						:	Tuple									=       pynb
											SCREAMING_SNAKE_CASE__						:	Tuple									=       img
											SCREAMING_SNAKE_CASE__						:	str									=       edgecolor
											SCREAMING_SNAKE_CASE__						:	List[str]									=       0.5
											SCREAMING_SNAKE_CASE__						:	Any									=       linestyle
											SCREAMING_SNAKE_CASE__						:	Dict									=       int(np.sqrt(min(UpperCamelCase__       ,	UpperCamelCase__   )   ) * scale // 3   )
											SCREAMING_SNAKE_CASE__						:	Any									=       width
											SCREAMING_SNAKE_CASE__						:	int									=       height
											SCREAMING_SNAKE_CASE__						:	int									=       scale
											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       fig
											SCREAMING_SNAKE_CASE__						:	str									=       ax
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       pad
											SCREAMING_SNAKE_CASE__						:	List[Any]									=       idaobj
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       idaattr
											SCREAMING_SNAKE_CASE__						:	List[Any]									=       FigureCanvasAgg(UpperCamelCase__   )



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__=None   ):



											"""simple docstring"""




											if color is None:
																		SCREAMING_SNAKE_CASE__						:	Dict									=       self.edgecolor
											((SCREAMING_SNAKE_CASE__)				,				(SCREAMING_SNAKE_CASE__)				,				(SCREAMING_SNAKE_CASE__)				,				(SCREAMING_SNAKE_CASE__))						:	List[Any]									=       box
											SCREAMING_SNAKE_CASE__						:	Dict									=       xa - xa
											SCREAMING_SNAKE_CASE__						:	List[str]									=       ya - ya
											self.ax.add_patch(
											    mpl.patches.Rectangle(
											        (xa, ya)       ,	UpperCamelCase__       ,	UpperCamelCase__       ,	fill=UpperCamelCase__       ,	edgecolor=UpperCamelCase__       ,	linewidth=self.font_size // 3       ,	alpha=self.alpha       ,	linestyle=self.linestyle       ,	)   )



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__=None       ,	SCREAMING_SNAKE_CASE__=None       ,	SCREAMING_SNAKE_CASE__=None       ,	SCREAMING_SNAKE_CASE__=None   ):



											"""simple docstring"""




											if len(boxes.shape   ) > 2:
																		SCREAMING_SNAKE_CASE__						:	List[str]									=       boxes[0]
											if len(obj_ids.shape   ) > 1:
																		SCREAMING_SNAKE_CASE__						:	int									=       obj_ids[0]
											if len(obj_scores.shape   ) > 1:
																		SCREAMING_SNAKE_CASE__						:	Dict									=       obj_scores[0]
											if len(attr_ids.shape   ) > 1:
																		SCREAMING_SNAKE_CASE__						:	Dict									=       attr_ids[0]
											if len(attr_scores.shape   ) > 1:
																		SCREAMING_SNAKE_CASE__						:	Tuple									=       attr_scores[0]
											if isinstance(UpperCamelCase__       ,	torch.Tensor   ):
																		SCREAMING_SNAKE_CASE__						:	Tuple									=       boxes.numpy()
											if isinstance(UpperCamelCase__       ,	UpperCamelCase__   ):
																		SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       np.array(UpperCamelCase__   )
											assert isinstance(UpperCamelCase__       ,	np.ndarray   )
											SCREAMING_SNAKE_CASE__						:	Tuple									=       np.prod(boxes[:, 2:] - boxes[:, :2]       ,	axis=1   )
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       np.argsort(-areas   ).tolist()
											SCREAMING_SNAKE_CASE__						:	Dict									=       boxes[sorted_idxs] if boxes is not None else None
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       obj_ids[sorted_idxs] if obj_ids is not None else None
											SCREAMING_SNAKE_CASE__						:	Dict									=       obj_scores[sorted_idxs] if obj_scores is not None else None
											SCREAMING_SNAKE_CASE__						:	List[Any]									=       attr_ids[sorted_idxs] if attr_ids is not None else None
											SCREAMING_SNAKE_CASE__						:	List[str]									=       attr_scores[sorted_idxs] if attr_scores is not None else None

											SCREAMING_SNAKE_CASE__						:	str									=       [self._random_color(maximum=1   ) for _ in range(len(UpperCamelCase__   )   )]
											SCREAMING_SNAKE_CASE__						:	List[str]									=       [assigned_colors[idx] for idx in sorted_idxs]
											if obj_ids is not None:
																		SCREAMING_SNAKE_CASE__						:	List[Any]									=       self._create_text_labels_attr(UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__   )
																		for i in range(len(UpperCamelCase__   )   ):
																									SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       assigned_colors[i]
																									self.add_box(boxes[i]       ,	UpperCamelCase__   )
																									self.draw_labels(labels[i]       ,	boxes[i]       ,	UpperCamelCase__   )



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__   ):



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Dict									=       box
											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       (xa, ya)
											SCREAMING_SNAKE_CASE__						:	int									=       (ya - ya) * (xa - xa)
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       _SMALL_OBJ * self.scale
											if instance_area < small or ya - ya < 40 * self.scale:
																		if ya >= self.height - 5:
																									SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       (xa, ya)
																		else:
																									SCREAMING_SNAKE_CASE__						:	int									=       (xa, ya)

											SCREAMING_SNAKE_CASE__						:	List[Any]									=       (ya - ya) / np.sqrt(self.height * self.width   )
											SCREAMING_SNAKE_CASE__						:	Any									=       self._change_color_brightness(UpperCamelCase__       ,	brightness_factor=0.7   )
											SCREAMING_SNAKE_CASE__						:	int									=       np.clip((height_ratio - 0.02) / 0.08 + 1       ,	1.2       ,	2   )
											font_size *= 0.75 * self.font_size

											self.draw_text(
											    text=UpperCamelCase__       ,	position=UpperCamelCase__       ,	color=UpperCamelCase__       ,	)



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__="g"       ,	SCREAMING_SNAKE_CASE__="left"       ,	):



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	Any									=       0
											SCREAMING_SNAKE_CASE__						:	List[str]									=       self.font_size
											SCREAMING_SNAKE_CASE__						:	int									=       np.maximum(list(mplc.to_rgb(UpperCamelCase__   )   )       ,	0.2   )
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       max(0.8       ,	np.max(UpperCamelCase__   )   )
											SCREAMING_SNAKE_CASE__						:	str									=       {
											    """facecolor""": """black""",
											    """alpha""": self.alpha,
											    """pad""": self.pad,
											    """edgecolor""": """none""",
											}
											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	List[Any]									=       position
											self.ax.text(
											    UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__       ,	size=font_size * self.scale       ,	family="""sans-serif"""       ,	bbox=UpperCamelCase__       ,	verticalalignment="""top"""       ,	horizontalalignment=UpperCamelCase__       ,	color=UpperCamelCase__       ,	zorder=10       ,	rotation=UpperCamelCase__       ,	)



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__=None   ):



											"""simple docstring"""




											if saveas is None:
																		SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       self.saveas
											if saveas.lower().endswith(""".jpg"""   ) or saveas.lower().endswith(""".png"""   ):
																		cva.imwrite(
																		    UpperCamelCase__       ,	self._get_buffer()[:, :, ::-1]       ,	)
											else:
																		self.fig.savefig(UpperCamelCase__   )



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__   ):



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	str									=       [self.idaobj[i] for i in classes]
											SCREAMING_SNAKE_CASE__						:	List[Any]									=       [self.idaattr[i] for i in attr_classes]
											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       [
											    F'''{label} {score:.2f} {attr} {attr_score:.2f}'''
											    for label, score, attr, attr_score in zip(UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__   )
											]
											return labels



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__   ):



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	int									=       [self.idaobj[i] for i in classes]
											if scores is not None:
																		if labels is None:
																									SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       ["""{:.0f}%""".format(s * 1_00   ) for s in scores]
																		else:
																									SCREAMING_SNAKE_CASE__						:	Tuple									=       ["""{} {:.0f}%""".format(UpperCamelCase__       ,	s * 1_00   ) for li, s in zip(UpperCamelCase__       ,	UpperCamelCase__   )]
											return labels



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__=2_55   ):



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       np.random.randint(0       ,	len(_COLORS   )   )
											SCREAMING_SNAKE_CASE__						:	int									=       _COLORS[idx] * maximum
											if not self.rgb:
																		SCREAMING_SNAKE_CASE__						:	Tuple									=       ret[::-1]
											return ret



				def      __magic_name__   (self   ):



											"""simple docstring"""




											if not self.pynb:
																		SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       self.canvas.print_to_buffer()
																		if (width, height) != (self.width, self.height):
																									SCREAMING_SNAKE_CASE__						:	Optional[int]									=       cva.resize(self.img       ,	(width, height)   )
																		else:
																									SCREAMING_SNAKE_CASE__						:	List[str]									=       self.img
											else:
																		SCREAMING_SNAKE_CASE__						:	str									=       io.BytesIO()  # works for cairo backend
																		self.canvas.print_rgba(UpperCamelCase__   )
																		SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       self.width, self.height
																		SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       buf.getvalue()
																		SCREAMING_SNAKE_CASE__						:	Optional[int]									=       self.img

											SCREAMING_SNAKE_CASE__						:	int									=       np.frombuffer(UpperCamelCase__       ,	dtype="""uint8"""   )
											SCREAMING_SNAKE_CASE__						:	Any									=       buffer.reshape(UpperCamelCase__       ,	UpperCamelCase__       ,	4   )
											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Dict									=       np.split(UpperCamelCase__       ,	[3]       ,	axis=2   )

											try:
																		import numexpr as ne  # fuse them with numexpr

																		SCREAMING_SNAKE_CASE__						:	str									=       ne.evaluate("""img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"""   )
											except ImportError:
																		SCREAMING_SNAKE_CASE__						:	Tuple									=       alpha.astype("""float32"""   ) / 255.0
																		SCREAMING_SNAKE_CASE__						:	Tuple									=       img * (1 - alpha) + rgb * alpha

											return visualized_image.astype("""uint8"""   )



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__   ):



											"""simple docstring"""




											assert brightness_factor >= -1.0 and brightness_factor <= 1.0
											SCREAMING_SNAKE_CASE__						:	Any									=       mplc.to_rgb(UpperCamelCase__   )
											SCREAMING_SNAKE_CASE__						:	List[str]									=       colorsys.rgb_to_hls(*mplc.to_rgb(UpperCamelCase__   )   )
											SCREAMING_SNAKE_CASE__						:	List[str]									=       polygon_color[1] + (brightness_factor * polygon_color[1])
											SCREAMING_SNAKE_CASE__						:	Dict									=       0.0 if modified_lightness < 0.0 else modified_lightness
											SCREAMING_SNAKE_CASE__						:	Any									=       1.0 if modified_lightness > 1.0 else modified_lightness
											SCREAMING_SNAKE_CASE__						:	List[Any]									=       colorsys.hls_to_rgb(polygon_color[0]       ,	UpperCamelCase__       ,	polygon_color[2]   )
											return modified_color






UpperCAmelCase__				:   Optional[int]   							=			(
    np.array(
        [
            0.000,
            0.447,
            0.741,
            0.850,
            0.325,
            0.098,
            0.929,
            0.694,
            0.125,
            0.494,
            0.184,
            0.556,
            0.466,
            0.674,
            0.188,
            0.301,
            0.745,
            0.933,
            0.635,
            0.078,
            0.184,
            0.300,
            0.300,
            0.300,
            0.600,
            0.600,
            0.600,
            1.000,
            0.000,
            0.000,
            1.000,
            0.500,
            0.000,
            0.749,
            0.749,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.333,
            0.333,
            0.000,
            0.333,
            0.667,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            0.333,
            0.000,
            0.667,
            0.667,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            1.000,
            0.000,
            0.000,
            0.333,
            0.500,
            0.000,
            0.667,
            0.500,
            0.000,
            1.000,
            0.500,
            0.333,
            0.000,
            0.500,
            0.333,
            0.333,
            0.500,
            0.333,
            0.667,
            0.500,
            0.333,
            1.000,
            0.500,
            0.667,
            0.000,
            0.500,
            0.667,
            0.333,
            0.500,
            0.667,
            0.667,
            0.500,
            0.667,
            1.000,
            0.500,
            1.000,
            0.000,
            0.500,
            1.000,
            0.333,
            0.500,
            1.000,
            0.667,
            0.500,
            1.000,
            1.000,
            0.500,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.333,
            0.333,
            1.000,
            0.333,
            0.667,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.667,
            0.333,
            1.000,
            0.667,
            0.667,
            1.000,
            0.667,
            1.000,
            1.000,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            1.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.143,
            0.143,
            0.143,
            0.857,
            0.857,
            0.857,
            1.000,
            1.000,
            1.000,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)






"""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       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__=13       ,	SCREAMING_SNAKE_CASE__=32       ,	SCREAMING_SNAKE_CASE__=2       ,	SCREAMING_SNAKE_CASE__=3       ,	SCREAMING_SNAKE_CASE__=16       ,	SCREAMING_SNAKE_CASE__=[1, 2, 1]       ,	SCREAMING_SNAKE_CASE__=[2, 2, 4]       ,	SCREAMING_SNAKE_CASE__=2       ,	SCREAMING_SNAKE_CASE__=2.0       ,	SCREAMING_SNAKE_CASE__=True       ,	SCREAMING_SNAKE_CASE__=0.0       ,	SCREAMING_SNAKE_CASE__=0.0       ,	SCREAMING_SNAKE_CASE__=0.1       ,	SCREAMING_SNAKE_CASE__="gelu"       ,	SCREAMING_SNAKE_CASE__=False       ,	SCREAMING_SNAKE_CASE__=True       ,	SCREAMING_SNAKE_CASE__=0.02       ,	SCREAMING_SNAKE_CASE__=1E-5       ,	SCREAMING_SNAKE_CASE__=True       ,	SCREAMING_SNAKE_CASE__=None       ,	SCREAMING_SNAKE_CASE__=True       ,	SCREAMING_SNAKE_CASE__=10       ,	SCREAMING_SNAKE_CASE__=8       ,	) ->		List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	List[str]									=       parent
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       batch_size
											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       image_size
											SCREAMING_SNAKE_CASE__						:	List[str]									=       patch_size
											SCREAMING_SNAKE_CASE__						:	List[str]									=       num_channels
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       embed_dim
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       depths
											SCREAMING_SNAKE_CASE__						:	List[Any]									=       num_heads
											SCREAMING_SNAKE_CASE__						:	str									=       window_size
											SCREAMING_SNAKE_CASE__						:	List[str]									=       mlp_ratio
											SCREAMING_SNAKE_CASE__						:	Tuple									=       qkv_bias
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       hidden_dropout_prob
											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       attention_probs_dropout_prob
											SCREAMING_SNAKE_CASE__						:	List[str]									=       drop_path_rate
											SCREAMING_SNAKE_CASE__						:	str									=       hidden_act
											SCREAMING_SNAKE_CASE__						:	Any									=       use_absolute_embeddings
											SCREAMING_SNAKE_CASE__						:	Any									=       patch_norm
											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       layer_norm_eps
											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       initializer_range
											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       is_training
											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       scope
											SCREAMING_SNAKE_CASE__						:	List[str]									=       use_labels
											SCREAMING_SNAKE_CASE__						:	str									=       type_sequence_label_size
											SCREAMING_SNAKE_CASE__						:	str									=       encoder_stride



				def      __magic_name__   (self   ) ->		Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

											SCREAMING_SNAKE_CASE__						:	List[str]									=       self.get_config()

											return config, pixel_values, labels



				def      __magic_name__   (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      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__   ) ->		int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       DonutSwinModel(config=SCREAMING_SNAKE_CASE__   )
											model.to(SCREAMING_SNAKE_CASE__   )
											model.eval()
											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       model(SCREAMING_SNAKE_CASE__   )

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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       self.prepare_config_and_inputs()
											(
											    (
											    SCREAMING_SNAKE_CASE__
											)				,				(
											    SCREAMING_SNAKE_CASE__
											)				,				(
											    SCREAMING_SNAKE_CASE__
											)				,				
											)						:	List[Any]									=       config_and_inputs
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       {"""pixel_values""": pixel_values}
											return config, inputs_dict






@require_torch
class      lowerCAmelCase_						(a__			, a__			, unittest.TestCase  ):


				"""simple docstring"""



				__UpperCamelCase				:						str 	=       (DonutSwinModel,) if is_torch_available() else ()
				__UpperCamelCase				:						str 	=       {'''feature-extraction''': DonutSwinModel} if is_torch_available() else {}
				__UpperCamelCase				:						List[str] 	=       True

				__UpperCamelCase				:						str 	=       False
				__UpperCamelCase				:						List[Any] 	=       False
				__UpperCamelCase				:						List[Any] 	=       False



				def      __magic_name__   (self   ) ->		Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	Any									=       DonutSwinModelTester(self   )
											SCREAMING_SNAKE_CASE__						:	Dict									=       ConfigTester(self       ,	config_class=SCREAMING_SNAKE_CASE__       ,	embed_dim=37   )



				def      __magic_name__   (self   ) ->		int:



											"""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      __magic_name__   (self   ) ->		Optional[Any]:



											"""simple docstring"""




											return



				def      __magic_name__   (self   ) ->		Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__   )



				def      __magic_name__   (self   ) ->		List[str]:



											"""simple docstring"""




											pass



				def      __magic_name__   (self   ) ->		List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       self.model_tester.prepare_config_and_inputs_for_common()

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



				def      __magic_name__   (self   ) ->		Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	List[Any]									=       self.model_tester.prepare_config_and_inputs_for_common()

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

																		SCREAMING_SNAKE_CASE__						:	str									=       ["""pixel_values"""]
																		self.assertListEqual(arg_names[:1]       ,	SCREAMING_SNAKE_CASE__   )



				def      __magic_name__   (self   ) ->		Optional[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	int									=       self.model_tester.prepare_config_and_inputs_for_common()
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       True

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

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

																		self.assertListEqual(
																		    list(attentions[0].shape[-3:]   )       ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,	)
																		SCREAMING_SNAKE_CASE__						:	List[str]									=       len(SCREAMING_SNAKE_CASE__   )

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

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

																		SCREAMING_SNAKE_CASE__						:	List[Any]									=       outputs.attentions

																		self.assertEqual(len(SCREAMING_SNAKE_CASE__   )       ,	SCREAMING_SNAKE_CASE__   )

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



				def      __magic_name__   (self       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__   ) ->		List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:	List[Any]									=       model_class(SCREAMING_SNAKE_CASE__   )
											model.to(SCREAMING_SNAKE_CASE__   )
											model.eval()

											with torch.no_grad():
																		SCREAMING_SNAKE_CASE__						:	str									=       model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__   )   )

											SCREAMING_SNAKE_CASE__						:	Optional[int]									=       outputs.hidden_states

											SCREAMING_SNAKE_CASE__						:	List[str]									=       getattr(
											    self.model_tester       ,	"""expected_num_hidden_layers"""       ,	len(self.model_tester.depths   ) + 1   )
											self.assertEqual(len(SCREAMING_SNAKE_CASE__   )       ,	SCREAMING_SNAKE_CASE__   )

											# DonutSwin has a different seq_length
											SCREAMING_SNAKE_CASE__						:	Any									=       (
											    config.patch_size
											    if isinstance(config.patch_size       ,	collections.abc.Iterable   )
											    else (config.patch_size, config.patch_size)
											)

											SCREAMING_SNAKE_CASE__						:	int									=       (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]       ,	)

											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       outputs.reshaped_hidden_states
											self.assertEqual(len(SCREAMING_SNAKE_CASE__   )       ,	SCREAMING_SNAKE_CASE__   )

											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       reshaped_hidden_states[0].shape
											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       (
											    reshaped_hidden_states[0].view(SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	height * width   ).permute(0       ,	2       ,	1   )
											)
											self.assertListEqual(
											    list(reshaped_hidden_states.shape[-2:]   )       ,	[num_patches, self.model_tester.embed_dim]       ,	)



				def      __magic_name__   (self   ) ->		Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Any									=       self.model_tester.prepare_config_and_inputs_for_common()

											SCREAMING_SNAKE_CASE__						:	Tuple									=       (
											    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:
																		SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       True
																		self.check_hidden_states_output(SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__   )

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       True

																		self.check_hidden_states_output(SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__   )



				def      __magic_name__   (self   ) ->		List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	Dict									=       self.model_tester.prepare_config_and_inputs_for_common()
											SCREAMING_SNAKE_CASE__						:	Tuple									=       3

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

											SCREAMING_SNAKE_CASE__						:	Optional[Any]									=       image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
											SCREAMING_SNAKE_CASE__						:	Union[str, Any]									=       image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

											for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE__						:	Any									=       True
																		self.check_hidden_states_output(SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	SCREAMING_SNAKE_CASE__       ,	(padded_height, padded_width)   )

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



				@slow
				def      __magic_name__   (self   ) ->		Union[str, Any]:



											"""simple docstring"""




											for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		SCREAMING_SNAKE_CASE__						:	Optional[int]									=       DonutSwinModel.from_pretrained(SCREAMING_SNAKE_CASE__   )
																		self.assertIsNotNone(SCREAMING_SNAKE_CASE__   )



				def      __magic_name__   (self   ) ->		List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__						:	str									=       self.model_tester.prepare_config_and_inputs_for_common()

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




