






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   :



      """simple docstring"""


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

        __UpperCAmelCase							:     Dict									=  None
        if self.use_labels:
          __UpperCAmelCase							:     Union[str, Any]									=  ids_tensor([self.batch_size]		,				self.type_sequence_label_size )

        __UpperCAmelCase							:     str									=  self.get_config()

        return config, pixel_values, labels
      def      UpperCAmelCase				(				self :      Optional[int] )							->				List[Any]:
        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      UpperCAmelCase				(				self :      Optional[int]		,				__lowercase :      List[Any]		,				__lowercase :      Any		,				__lowercase :      List[Any] )							->				Optional[Any]:
        __UpperCAmelCase							:     Tuple									=  DonutSwinModel(config=__lowercase )
        model.to(__lowercase )
        model.eval()
        __UpperCAmelCase							:     Optional[Any]									=  model(__lowercase )

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


@require_torch
class    a   (			lowercase__							,	lowercase__							,	unittest.TestCase       ):



      """simple docstring"""


      a  :			Optional[int]								=     (DonutSwinModel,) if is_torch_available() else ()
      a  :			Optional[Any]								=     {'feature-extraction': DonutSwinModel} if is_torch_available() else {}
      a  :			Any								=     True

      a  :			Any								=     False
      a  :			str								=     False
      a  :			str								=     False
      def      UpperCAmelCase				(				self :      Union[str, Any] )							->				Union[str, Any]:
        __UpperCAmelCase							:     Dict									=  DonutSwinModelTester(self )
        __UpperCAmelCase							:     List[Any]									=  ConfigTester(self		,				config_class=__lowercase		,				embed_dim=37 )
      def      UpperCAmelCase				(				self :      Optional[int] )							->				int:
        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      UpperCAmelCase				(				self :      Union[str, Any] )							->				Optional[int]:
        return
      def      UpperCAmelCase				(				self :      Any )							->				Tuple:
        __UpperCAmelCase							:     Any									=  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__lowercase )
      def      UpperCAmelCase				(				self :      Optional[int] )							->				Union[str, Any]:
        # DonutSwin does not use inputs_embeds
        pass
      def      UpperCAmelCase				(				self :      str )							->				Tuple:
        __UpperCAmelCase				,			__UpperCAmelCase							:     Dict									=  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          __UpperCAmelCase							:     Dict									=  model_class(__lowercase )
          self.assertIsInstance(model.get_input_embeddings()		,				(nn.Module) )
          __UpperCAmelCase							:     Tuple									=  model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(__lowercase		,				nn.Linear ) )
      def      UpperCAmelCase				(				self :      List[str] )							->				Union[str, Any]:
        __UpperCAmelCase				,			__UpperCAmelCase							:     List[Any]									=  self.model_tester.prepare_config_and_inputs_for_common()

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

          __UpperCAmelCase							:     Optional[int]									=  ["""pixel_values"""]
          self.assertListEqual(arg_names[:1]		,				__lowercase )
      def      UpperCAmelCase				(				self :      Optional[int] )							->				List[str]:
        __UpperCAmelCase				,			__UpperCAmelCase							:     Optional[Any]									=  self.model_tester.prepare_config_and_inputs_for_common()
        __UpperCAmelCase							:     str									=  True

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

          # check that output_attentions also work using config
          del inputs_dict["output_attentions"]
          __UpperCAmelCase							:     int									=  True
          __UpperCAmelCase							:     str									=  config.window_size**2
          __UpperCAmelCase							:     Tuple									=  model_class(__lowercase )
          model.to(__lowercase )
          model.eval()
          with torch.no_grad():
            __UpperCAmelCase							:     Tuple									=  model(**self._prepare_for_class(__lowercase		,				__lowercase ) )
          __UpperCAmelCase							:     Union[str, Any]									=  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]		,				)
          __UpperCAmelCase							:     Tuple									=  len(__lowercase )

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

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

          __UpperCAmelCase							:     Optional[int]									=  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      UpperCAmelCase				(				self :      List[Any]		,				__lowercase :      int		,				__lowercase :      Any		,				__lowercase :      str		,				__lowercase :      Optional[Any] )							->				str:
        __UpperCAmelCase							:     List[Any]									=  model_class(__lowercase )
        model.to(__lowercase )
        model.eval()

        with torch.no_grad():
          __UpperCAmelCase							:     int									=  model(**self._prepare_for_class(__lowercase		,				__lowercase ) )

        __UpperCAmelCase							:     int									=  outputs.hidden_states

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

        __UpperCAmelCase							:     List[Any]									=  (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]		,				)

        __UpperCAmelCase							:     str									=  outputs.reshaped_hidden_states
        self.assertEqual(len(__lowercase )		,				__lowercase )

        __UpperCAmelCase				,			__UpperCAmelCase				,			__UpperCAmelCase				,			__UpperCAmelCase							:     Union[str, Any]									=  reshaped_hidden_states[0].shape
        __UpperCAmelCase							:     str									=  (
            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      UpperCAmelCase				(				self :      Optional[int] )							->				List[Any]:
        __UpperCAmelCase				,			__UpperCAmelCase							:     str									=  self.model_tester.prepare_config_and_inputs_for_common()

        __UpperCAmelCase							:     List[str]									=  (
            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:
          __UpperCAmelCase							:     Optional[int]									=  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"]
          __UpperCAmelCase							:     Optional[int]									=  True

          self.check_hidden_states_output(__lowercase		,				__lowercase		,				__lowercase		,				__lowercase )
      def      UpperCAmelCase				(				self :      int )							->				List[Any]:
        __UpperCAmelCase				,			__UpperCAmelCase							:     Optional[Any]									=  self.model_tester.prepare_config_and_inputs_for_common()
        __UpperCAmelCase							:     List[str]									=  3

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

        __UpperCAmelCase							:     Optional[Any]									=  image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
        __UpperCAmelCase							:     List[str]									=  image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

        for model_class in self.all_model_classes:
          __UpperCAmelCase							:     Optional[int]									=  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"]
          __UpperCAmelCase							:     Optional[Any]									=  True
          self.check_hidden_states_output(__lowercase		,				__lowercase		,				__lowercase		,				(padded_height, padded_width) )
      @slow
      def      UpperCAmelCase				(				self :      Dict )							->				List[Any]:
        for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          __UpperCAmelCase							:     Dict									=  DonutSwinModel.from_pretrained(__lowercase )
          self.assertIsNotNone(__lowercase )




      def      UpperCAmelCase				(				self :      List[Any] )							->				List[Any]:
        __UpperCAmelCase				,			__UpperCAmelCase							:     Tuple									=  self.model_tester.prepare_config_and_inputs_for_common()

        __UpperCAmelCase							:     Optional[int]									=  _config_zero_init(__lowercase )
        for model_class in self.all_model_classes:
          __UpperCAmelCase							:     int									=  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"""		,				)










def     lowerCamelCase__				(   ):

  for a in range(300		):
    for b in range(a + 1  ,		400		):
      for c in range(b + 1  ,		500		):
        if (a + b + c) == 1000 and (a**2) + (b**2) == (c**2):
          return a * b * c

  return -1






def     lowerCamelCase__				(   ):

  for a in range(300		):
    for b in range(400		):
      __UpperCAmelCase							:     Optional[Any]									=  1000 - a - b
      if a < b < c and (a**2) + (b**2) == (c**2):
        return a * b * c

  return -1






def     lowerCamelCase__				(   ):
  import timeit

  print(
      timeit.timeit("""solution()"""  ,		setup="""from __main__ import solution"""  ,		number=1000		)		)
  print(
      timeit.timeit(
          """solution_fast()"""  ,		setup="""from __main__ import solution_fast"""  ,		number=1000		)		)


if __name__ == "__main__":
       print(f"""{solution() = }""")


