



import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch
 from torch import nn

 from transformers import MaskFormerSwinBackbone
 from transformers.models.maskformer import MaskFormerSwinModel

class    _A	:



       def __init__(		self							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=13					,		__SCREAMING_SNAKE_CASE							:					Dict=32					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=2					,		__SCREAMING_SNAKE_CASE							:					int=3					,		__SCREAMING_SNAKE_CASE							:					Dict=16					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]=[1, 2, 1]					,		__SCREAMING_SNAKE_CASE							:					str=[2, 2, 4]					,		__SCREAMING_SNAKE_CASE							:					int=2					,		__SCREAMING_SNAKE_CASE							:					Dict=2.0					,		__SCREAMING_SNAKE_CASE							:					Any=True					,		__SCREAMING_SNAKE_CASE							:					List[Any]=0.0					,		__SCREAMING_SNAKE_CASE							:					int=0.0					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]=0.1					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]="gelu"					,		__SCREAMING_SNAKE_CASE							:					str=False					,		__SCREAMING_SNAKE_CASE							:					str=True					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]=0.02					,		__SCREAMING_SNAKE_CASE							:					int=1E-5					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=True					,		__SCREAMING_SNAKE_CASE							:					Tuple=None					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]=True					,		__SCREAMING_SNAKE_CASE							:					List[str]=10					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=8					,		__SCREAMING_SNAKE_CASE							:					str=["stage1", "stage2", "stage3"]					,		__SCREAMING_SNAKE_CASE							:					str=[1, 2, 3]					,		):


           '''simple docstring'''

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



       def 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

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

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

           __a							=    self.get_config()

           return config, pixel_values, labels



       def 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

           return MaskFormerSwinConfig(
               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					,		out_features=self.out_features					,		out_indices=self.out_indices					,		)



       def 		_lowerCamelCase      (		self							:					int					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					str					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]):


           '''simple docstring'''

           __a							=    MaskFormerSwinModel(config=__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    model(__SCREAMING_SNAKE_CASE)

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


           '''simple docstring'''

           __a							=    MaskFormerSwinBackbone(config=__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    model(__SCREAMING_SNAKE_CASE)

           # verify feature maps
           self.parent.assertEqual(len(result.feature_maps)					,		len(config.out_features))
           self.parent.assertListEqual(list(result.feature_maps[0].shape)					,		[13, 16, 16, 16])

           # verify channels
           self.parent.assertEqual(len(model.channels)					,		len(config.out_features))
           self.parent.assertListEqual(model.channels					,		[16, 32, 64])

           # verify ValueError
           with self.parent.assertRaises(__SCREAMING_SNAKE_CASE):
               __a							=    ['''stem''']
               __a							=    MaskFormerSwinBackbone(config=__SCREAMING_SNAKE_CASE)





       def 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

           __a							=    self.prepare_config_and_inputs()
           __a	,       __a	,       __a							=    config_and_inputs
           __a							=    {'''pixel_values''': pixel_values}
           return config, inputs_dict


@require_torch
class    _A	(     __UpperCAmelCase				,__UpperCAmelCase				,unittest.TestCase   ):
       UpperCamelCase__  :   Tuple						 =						(
           (
               MaskFormerSwinModel,
               MaskFormerSwinBackbone,
           )
           if is_torch_available()
           else ()
       )
       UpperCamelCase__  :   List[Any]						 =						{'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {}
       UpperCamelCase__  :   str						 =						False
       UpperCamelCase__  :   Tuple						 =						False
       UpperCamelCase__  :   Tuple						 =						False
       UpperCamelCase__  :   Optional[Any]						 =						False
       UpperCamelCase__  :   List[str]						 =						False



       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           __a							=    MaskFormerSwinModelTester(self)
           __a							=    ConfigTester(self					,		config_class=__SCREAMING_SNAKE_CASE					,		embed_dim=37)



       @require_torch_multi_gpu
       @unittest.skip(
           reason=(
               '''`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'''
               ''' `nn.DataParallel`'''
           ))
       def 		_lowerCamelCase      (		self							:					int):


           '''simple docstring'''

           pass



       def 		_lowerCamelCase      (		self							:					Optional[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 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

           return



       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE)



       @unittest.skip('''Swin does not use inputs_embeds''')
       def 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

           pass



       @unittest.skip('''Swin does not support feedforward chunking''')
       def 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           pass



       def 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

           __a	,       __a							=    self.model_tester.prepare_config_and_inputs_for_common()

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



       def 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           __a	,       __a							=    self.model_tester.prepare_config_and_inputs_for_common()

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

               __a							=    ['''pixel_values''']
               self.assertListEqual(arg_names[:1]					,		__SCREAMING_SNAKE_CASE)



       @unittest.skip(reason='''MaskFormerSwin is only used as backbone and doesn\'t support output_attentions''')
       def 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

           pass



       @unittest.skip(reason='''MaskFormerSwin is only used as an internal backbone''')
       def 		_lowerCamelCase      (		self							:					Union[str, Any]):


           '''simple docstring'''

           pass



       def 		_lowerCamelCase      (		self							:					Any					,		__SCREAMING_SNAKE_CASE							:					List[Any]					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Any):


           '''simple docstring'''

           __a							=    model_class(__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()

           with torch.no_grad():
               __a							=    model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE))

           __a							=    outputs.hidden_states

           __a							=    getattr(
               self.model_tester					,		'''expected_num_hidden_layers'''					,		len(self.model_tester.depths) + 1)
           self.assertEqual(len(__SCREAMING_SNAKE_CASE)					,		__SCREAMING_SNAKE_CASE)

           # Swin has a different seq_length
           __a							=    (
               config.patch_size
               if isinstance(config.patch_size					,		collections.abc.Iterable)
               else (config.patch_size, config.patch_size)
           )

           __a							=    (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]					,		)



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


           '''simple docstring'''

           __a	,       __a							=    self.model_tester.prepare_config_and_inputs_for_common()

           __a							=    (
               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:
               __a							=    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"]
               __a							=    True

               self.check_hidden_states_output(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           __a	,       __a							=    self.model_tester.prepare_config_and_inputs_for_common()
           __a							=    3

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

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

           for model_class in self.all_model_classes:
               __a							=    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"]
               __a							=    True
               self.check_hidden_states_output(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		(padded_height, padded_width))



       @unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints''')
       def 		_lowerCamelCase      (		self							:					List[Any]):


           '''simple docstring'''

           pass



       @unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin''')
       def 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

           pass



       @unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin''')
       def 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

           pass





       def 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           __a	,       __a							=    self.model_tester.prepare_config_and_inputs_for_common()

           def set_nan_tensor_to_zero(__SCREAMING_SNAKE_CASE							:					Any):
               __a							=    0
               return t

           def check_equivalence(__SCREAMING_SNAKE_CASE							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					Dict={}):
               with torch.no_grad():
                   __a							=    model(**__SCREAMING_SNAKE_CASE					,		return_dict=__SCREAMING_SNAKE_CASE					,		**__SCREAMING_SNAKE_CASE)
                   __a							=    model(**__SCREAMING_SNAKE_CASE					,		return_dict=__SCREAMING_SNAKE_CASE					,		**__SCREAMING_SNAKE_CASE).to_tuple()

                   def recursive_check(__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					List[Any]):
                       if isinstance(__SCREAMING_SNAKE_CASE					,		(List, Tuple)):
                           for tuple_iterable_value, dict_iterable_value in zip(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE):
                               recursive_check(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)
                       elif isinstance(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE):
                           for tuple_iterable_value, dict_iterable_value in zip(
                               tuple_object.values()					,		dict_object.values()):
                               recursive_check(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)
                       elif tuple_object is None:
                           return
                       else:
                           self.assertTrue(
                               torch.allclose(
                                   set_nan_tensor_to_zero(__SCREAMING_SNAKE_CASE)					,		set_nan_tensor_to_zero(__SCREAMING_SNAKE_CASE)					,		atol=1E-5)					,		msg=(
                                   '''Tuple and dict output are not equal. Difference:'''
                                   F' {torch.max(torch.abs(tuple_object - dict_object))}. Tuple has `nan`:'
                                   F' {torch.isnan(__SCREAMING_SNAKE_CASE).any()} and `inf`: {torch.isinf(__SCREAMING_SNAKE_CASE)}. Dict has'
                                   F' `nan`: {torch.isnan(__SCREAMING_SNAKE_CASE).any()} and `inf`: {torch.isinf(__SCREAMING_SNAKE_CASE)}.'
                               )					,		)

                   recursive_check(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)

           for model_class in self.all_model_classes:
               __a							=    model_class(__SCREAMING_SNAKE_CASE)
               model.to(__SCREAMING_SNAKE_CASE)
               model.eval()

               __a							=    self._prepare_for_class(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)
               __a							=    self._prepare_for_class(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)
               check_equivalence(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)

               __a							=    self._prepare_for_class(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		return_labels=__SCREAMING_SNAKE_CASE)
               __a							=    self._prepare_for_class(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		return_labels=__SCREAMING_SNAKE_CASE)
               check_equivalence(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)

               __a							=    self._prepare_for_class(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)
               __a							=    self._prepare_for_class(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)
               check_equivalence(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		{'''output_hidden_states''': True})

               __a							=    self._prepare_for_class(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		return_labels=__SCREAMING_SNAKE_CASE)
               __a							=    self._prepare_for_class(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		return_labels=__SCREAMING_SNAKE_CASE)
               check_equivalence(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		{'''output_hidden_states''': True})


@require_torch
class    _A	(     unittest.TestCase				,__UpperCAmelCase   ):
       UpperCamelCase__  :   Any						 =						(MaskFormerSwinBackbone,) if is_torch_available() else ()
       UpperCamelCase__  :   Union[str, Any]						 =						MaskFormerSwinConfig



       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           __a							=    MaskFormerSwinModelTester(self)





       def 		_lowerCamelCase      (		self							:					int):


           '''simple docstring'''

           __a	,       __a							=    self.model_tester.prepare_config_and_inputs_for_common()
           __a							=    inputs_dict['''pixel_values'''].shape[0]

           for backbone_class in self.all_model_classes:
               __a							=    backbone_class(__SCREAMING_SNAKE_CASE)
               backbone.to(__SCREAMING_SNAKE_CASE)
               backbone.eval()

               __a							=    backbone(**__SCREAMING_SNAKE_CASE)

               # Test default outputs and verify feature maps
               self.assertIsInstance(outputs.feature_maps					,		__SCREAMING_SNAKE_CASE)
               self.assertTrue(len(outputs.feature_maps) == len(backbone.channels))
               for feature_map, n_channels in zip(outputs.feature_maps					,		backbone.channels):
                   self.assertTrue(feature_map.shape[:2]					,		(batch_size, n_channels))
               self.assertIsNone(outputs.hidden_states)
               self.assertIsNone(outputs.attentions)

               # Test output_hidden_states=True
               __a							=    backbone(**__SCREAMING_SNAKE_CASE					,		output_hidden_states=__SCREAMING_SNAKE_CASE)
               self.assertIsNotNone(outputs.hidden_states)
               self.assertTrue(len(outputs.hidden_states)					,		len(backbone.stage_names))
               # We skip the stem layer
               for hidden_states, n_channels in zip(outputs.hidden_states[1:]					,		backbone.channels):
                   for hidden_state in hidden_states:
                       # Hidden states are in the format (batch_size, (height * width), n_channels)
                       __a	,       __a	,       __a							=    hidden_state.shape
                       self.assertTrue((h_batch_size, h_n_channels)					,		(batch_size, n_channels))

            # Test output_attentions=True
               if self.has_attentions:
                   __a							=    backbone(**__SCREAMING_SNAKE_CASE					,		output_attentions=__SCREAMING_SNAKE_CASE)
                   self.assertIsNotNone(outputs.attentions)










import unittest

from transformers import DonutProcessor


__snake_case						:List[str]						=					'''naver-clova-ix/donut-base'''

class    _A	(     unittest.TestCase   ):



       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           __a							=    DonutProcessor.from_pretrained(__SCREAMING_SNAKE_CASE)





       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           __a							=    {
               '''name''': '''John Doe''',
               '''age''': '''99''',
               '''city''': '''Atlanta''',
               '''state''': '''GA''',
               '''zip''': '''30301''',
               '''phone''': '''123-4567''',
               '''nicknames''': [{'''nickname''': '''Johnny'''}, {'''nickname''': '''JD'''}],
           }

           __a							=    (
               '''<s_name>John Doe</s_name><s_age>99</s_age><s_city>Atlanta</s_city>'''
               '''<s_state>GA</s_state><s_zip>30301</s_zip><s_phone>123-4567</s_phone>'''
               '''<s_nicknames><s_nickname>Johnny</s_nickname>'''
               '''<sep/><s_nickname>JD</s_nickname></s_nicknames>'''
           )
           __a							=    self.processor.tokenajson(__SCREAMING_SNAKE_CASE)

           self.assertDictEqual(__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)





