




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


       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      ,					) ->					Any:



            '''simple docstring'''




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


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



            '''simple docstring'''




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

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

            __snake_case         =					self.get_config()

            return config, pixel_values, labels


       def  lowerCAmelCase (				self					) ->					Optional[int]:



            '''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  lowerCAmelCase (				self      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					) ->					List[str]:



            '''simple docstring'''




            __snake_case         =					DonutSwinModel(config=__SCREAMING_SNAKE_CASE					)
            model.to(__SCREAMING_SNAKE_CASE					)
            model.eval()
            __snake_case         =					model(__SCREAMING_SNAKE_CASE					)

            __snake_case         =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
            __snake_case         =					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					) ->					Tuple:



            '''simple docstring'''




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





@require_torch
class       lowerCAmelCase	(	__lowerCAmelCase			,				__lowerCAmelCase			,				unittest.TestCase):
       __lowercase					: Dict	    =     (DonutSwinModel,) if is_torch_available() else ()
       __lowercase					: Any	    =     {'''feature-extraction''': DonutSwinModel} if is_torch_available() else {}
       __lowercase					: Tuple	    =     True

       __lowercase					: str	    =     False
       __lowercase					: str	    =     False
       __lowercase					: Tuple	    =     False


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



            '''simple docstring'''




            __snake_case         =					DonutSwinModelTester(self					)
            __snake_case         =					ConfigTester(self      ,					config_class=__SCREAMING_SNAKE_CASE      ,					embed_dim=37					)


       def  lowerCAmelCase (				self					) ->					Dict:



            '''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					) ->					Dict:



            '''simple docstring'''




            return


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



            '''simple docstring'''




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


       def  lowerCAmelCase (				self					) ->					Tuple:



            '''simple docstring'''




            pass


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



            '''simple docstring'''




            __snake_case   ,      __snake_case         =					self.model_tester.prepare_config_and_inputs_for_common()

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


       def  lowerCAmelCase (				self					) ->					Tuple:



            '''simple docstring'''




            __snake_case   ,      __snake_case         =					self.model_tester.prepare_config_and_inputs_for_common()

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

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


       def  lowerCAmelCase (				self					) ->					str:



            '''simple docstring'''




            __snake_case   ,      __snake_case         =					self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case         =					True

            for model_class in self.all_model_classes:
                 __snake_case         =					True
                 __snake_case         =					False
                 __snake_case         =					True
                 __snake_case         =					model_class(__SCREAMING_SNAKE_CASE					)
                 model.to(__SCREAMING_SNAKE_CASE					)
                 model.eval()
                 with torch.no_grad():
                      __snake_case         =					model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					)					)
                 __snake_case         =					outputs.attentions
                 __snake_case         =					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"]
                 __snake_case         =					True
                 __snake_case         =					config.window_size**2
                 __snake_case         =					model_class(__SCREAMING_SNAKE_CASE					)
                 model.to(__SCREAMING_SNAKE_CASE					)
                 model.eval()
                 with torch.no_grad():
                      __snake_case         =					model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					)					)
                 __snake_case         =					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]      ,					)
                 __snake_case         =					len(__SCREAMING_SNAKE_CASE					)

                 # Check attention is always last and order is fine
                 __snake_case         =					True
                 __snake_case         =					True
                 __snake_case         =					model_class(__SCREAMING_SNAKE_CASE					)
                 model.to(__SCREAMING_SNAKE_CASE					)
                 model.eval()
                 with torch.no_grad():
                      __snake_case         =					model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					)					)

                 if hasattr(self.model_tester      ,					'''num_hidden_states_types'''					):
                      __snake_case         =					self.model_tester.num_hidden_states_types
                 else:
                      # also another +1 for reshaped_hidden_states
                      __snake_case         =					2
                 self.assertEqual(out_len + added_hidden_states      ,					len(__SCREAMING_SNAKE_CASE					)					)

                 __snake_case         =					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  lowerCAmelCase (				self      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					) ->					Optional[int]:



            '''simple docstring'''




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

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

            __snake_case         =					outputs.hidden_states

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

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

            __snake_case         =					outputs.reshaped_hidden_states
            self.assertEqual(len(__SCREAMING_SNAKE_CASE					)      ,					__SCREAMING_SNAKE_CASE					)

            __snake_case   ,      __snake_case   ,      __snake_case   ,      __snake_case         =					reshaped_hidden_states[0].shape
            __snake_case         =					(
                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  lowerCAmelCase (				self					) ->					List[Any]:



            '''simple docstring'''




            __snake_case   ,      __snake_case         =					self.model_tester.prepare_config_and_inputs_for_common()

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

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


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



            '''simple docstring'''




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

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

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

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


       @slow
       def  lowerCAmelCase (				self					) ->					List[Any]:



            '''simple docstring'''




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




       def  lowerCAmelCase (				self					) ->					Any:



            '''simple docstring'''




            __snake_case   ,      __snake_case         =					self.model_tester.prepare_config_and_inputs_for_common()

            __snake_case         =					_config_zero_init(__SCREAMING_SNAKE_CASE					)
            for model_class in self.all_model_classes:
                 __snake_case         =					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'''      ,					)












'''simple docstring'''



def      _UpperCamelCase	(_lowerCamelCase							:       list				,		_lowerCamelCase							:       int		)->				int:




     '''simple docstring'''





     for index, item in enumerate(_lowerCamelCase		):
          if item == target:
               return index
     return -1







def      _UpperCamelCase	(_lowerCamelCase							:       list				,		_lowerCamelCase							:       int				,		_lowerCamelCase							:       int				,		_lowerCamelCase							:       int		)->				int:




     '''simple docstring'''





     if not (0 <= high < len(_lowerCamelCase		) and 0 <= low < len(_lowerCamelCase		)):
          raise Exception('''Invalid upper or lower bound!'''		)
     if high < low:
          return -1
     if sequence[low] == target:
          return low
     if sequence[high] == target:
          return high
     return rec_linear_search(_lowerCamelCase				,		low + 1				,		high - 1				,		_lowerCamelCase		)


if __name__ == "__main__":
     UpperCAmelCase_    :					List[Any]					      =						input('''Enter numbers separated by comma:\n''').strip()
     UpperCAmelCase_    :					Optional[int]					      =						[int(item.strip()) for item in user_input.split(''',''')]

     UpperCAmelCase_    :					List[str]					      =						int(input('''Enter a single number to be found in the list:\n''').strip())
     UpperCAmelCase_    :					Optional[int]					      =						linear_search(sequence, target)
     if result != -1:
          print(F"""linear_search({sequence}, {target}) = {result}""")
     else:
          print(F"""{target} was not found in {sequence}""")






