




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






						def __init__(  self						,     _A						,     _A=1_3						,     _A=3_2						,     _A=2						,     _A=3						,     _A=1_6						,     _A=[1, 2, 1]						,     _A=[2, 2, 4]						,     _A=2						,     _A=2.0						,     _A=True						,     _A=0.0						,     _A=0.0						,     _A=0.1						,     _A="gelu"						,     _A=False						,     _A=True						,     _A=0.02						,     _A=1E-5						,     _A=True						,     _A=None						,     _A=True						,     _A=1_0						,     _A=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 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self						,     _A						,     _A						,     _A     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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__       (   snake_case__					,							snake_case__					,							unittest.TestCase ):
						_a				:       Optional[Any]   =       (DonutSwinModel,) if is_torch_available() else ()
						_a				:       Dict   =       {"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
						_a				:       Dict   =       True

						_a				:       str   =       False
						_a				:       int   =       False
						_a				:       Any   =       False






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											__lowerCAmelCase							  =			DonutSwinModelTester(self     )
											__lowerCAmelCase							  =			ConfigTester(self						,     config_class=__lowercase						,     embed_dim=3_7     )






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											return






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											__lowerCAmelCase							  =			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__lowercase     )






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											pass






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self						,     _A						,     _A						,     _A						,     _A     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



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






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""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"""						,     )










UpperCamelCase__						=		[
    [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
    [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
    [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
]






def    snake_case   (				A		,  A		,  A		,  A     )				->				bool:




	'''simple docstring'''


	return 0 <= row < rows and 0 <= col < cols






def    snake_case   (				A		,  A		,  A		,  A     )				->				int:




	'''simple docstring'''


	lowerCamelCase_				:						List[str]				  =				len(A     )
	lowerCamelCase_				:						Any				  =				len(mat[0]     )
	if is_safe(A		,  A		,  A		,  A     ) and (row, col) not in seen and mat[row][col] == 1:
		seen.add((row, col)     )
		return (
		    1
		    + depth_first_search(row + 1		,  A		,  A		,  A     )
		    + depth_first_search(row - 1		,  A		,  A		,  A     )
		    + depth_first_search(A		,  col + 1		,  A		,  A     )
		    + depth_first_search(A		,  col - 1		,  A		,  A     )
		)
	else:
		return 0






def    snake_case   (				A     )				->				int:




	'''simple docstring'''


	lowerCamelCase_				:						set				  =				set()

	lowerCamelCase_				:						Optional[Any]				  =				0
	for row, line in enumerate(A     ):
		for col, item in enumerate(A     ):
			if item == 1 and (row, col) not in seen:
				# Maximizing the area
				lowerCamelCase_				:						Optional[Any]				  =				max(A		,  depth_first_search(A		,  A		,  A		,  A     )     )
	return max_area


if __name__ == "__main__":
							import doctest

							print(find_max_area(matrix))  # Output -> 6
							doctest.testmod()
