


import inspect
import unittest

import requests

from transformers import MgpstrConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import MgpstrForSceneTextRecognition


if is_vision_available():
		from PIL import Image

		from transformers import MgpstrProcessor

class 	__a   :
		def __init__(    self    ,					_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE=False    ,					_SCREAMING_SNAKE_CASE=13    ,					_SCREAMING_SNAKE_CASE=(32, 128)    ,					_SCREAMING_SNAKE_CASE=4    ,					_SCREAMING_SNAKE_CASE=3    ,					_SCREAMING_SNAKE_CASE=27    ,					_SCREAMING_SNAKE_CASE=38    ,					_SCREAMING_SNAKE_CASE=99    ,					_SCREAMING_SNAKE_CASE=99    ,					_SCREAMING_SNAKE_CASE=32    ,					_SCREAMING_SNAKE_CASE=5    ,					_SCREAMING_SNAKE_CASE=4    ,					_SCREAMING_SNAKE_CASE=4.0    ,					_SCREAMING_SNAKE_CASE=257    ,					_SCREAMING_SNAKE_CASE=None    ,					)				-> List[str]:




									"""simple docstring"""





									_UpperCAmelCase					=    parent
									_UpperCAmelCase					=    is_training
									_UpperCAmelCase					=    batch_size
									_UpperCAmelCase					=    image_size
									_UpperCAmelCase					=    patch_size
									_UpperCAmelCase					=    num_channels
									_UpperCAmelCase					=    max_token_length
									_UpperCAmelCase					=    num_character_labels
									_UpperCAmelCase					=    num_bpe_labels
									_UpperCAmelCase					=    num_wordpiece_labels
									_UpperCAmelCase					=    hidden_size
									_UpperCAmelCase					=    num_hidden_layers
									_UpperCAmelCase					=    num_attention_heads
									_UpperCAmelCase					=    mlp_ratio
									_UpperCAmelCase					=    patch_embeds_hidden_size
									_UpperCAmelCase					=    output_hidden_states
		def 			UpperCAmelCase__       (    self		)				-> Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=    floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]		)
									_UpperCAmelCase					=    self.get_config()
									return config, pixel_values
		def 			UpperCAmelCase__       (    self		)				-> Union[str, Any]:




									"""simple docstring"""





									return MgpstrConfig(
									    image_size=self.image_size    ,					patch_size=self.patch_size    ,					num_channels=self.num_channels    ,					max_token_length=self.max_token_length    ,					num_character_labels=self.num_character_labels    ,					num_bpe_labels=self.num_bpe_labels    ,					num_wordpiece_labels=self.num_wordpiece_labels    ,					hidden_size=self.hidden_size    ,					num_hidden_layers=self.num_hidden_layers    ,					num_attention_heads=self.num_attention_heads    ,					mlp_ratio=self.mlp_ratio    ,					output_hidden_states=self.output_hidden_states    ,					)
		def 			UpperCAmelCase__       (    self    ,					_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		)				-> Union[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase					=    MgpstrForSceneTextRecognition(_SCREAMING_SNAKE_CASE		)
									model.to(_SCREAMING_SNAKE_CASE		)
									model.eval()
									with torch.no_grad():
																_UpperCAmelCase					=    model(_SCREAMING_SNAKE_CASE		)
									self.parent.assertEqual(
									    generated_ids[0][0].shape    ,					(self.batch_size, self.max_token_length, self.num_character_labels)		)






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




									"""simple docstring"""





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



@require_torch
class 	__a   (       UpperCAmelCase					,   UpperCAmelCase					,   unittest.TestCase    ):
		_a			:						List[str]    			=			(MgpstrForSceneTextRecognition,) if is_torch_available() else ()
		_a			:						Optional[int]    			=			{'feature-extraction': MgpstrForSceneTextRecognition} if is_torch_available() else {}
		_a			:						Optional[Any]    			=			False

		_a			:						Optional[int]    			=			False
		_a			:						Optional[Any]    			=			False
		_a			:						str    			=			False
		_a			:						Tuple    			=			False
		def 			UpperCAmelCase__       (    self		)				-> Optional[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=    MgpstrModelTester(self		)
									_UpperCAmelCase					=    ConfigTester(self    ,					config_class=_SCREAMING_SNAKE_CASE    ,					has_text_modality=_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self		)				-> List[Any]:




									"""simple docstring"""





									self.config_tester.run_common_tests()
		def 			UpperCAmelCase__       (    self		)				-> Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE		)
		@unittest.skip(reason='MgpstrModel does not use inputs_embeds'		)
		def 			UpperCAmelCase__       (    self		)				-> List[Any]:




									"""simple docstring"""





									pass
		def 			UpperCAmelCase__       (    self		)				-> str:




									"""simple docstring"""





									_UpperCAmelCase	, _UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																_UpperCAmelCase					=    model_class(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(model.get_input_embeddings()    ,					(nn.Module)		)
																_UpperCAmelCase					=    model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE    ,					nn.Linear		)		)
		def 			UpperCAmelCase__       (    self		)				-> Union[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase	, _UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs_for_common()

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

																_UpperCAmelCase					=    ['pixel_values']
																self.assertListEqual(arg_names[:1]    ,					_SCREAMING_SNAKE_CASE		)
		@unittest.skip(reason='MgpstrModel does not support feedforward chunking'		)
		def 			UpperCAmelCase__       (    self		)				-> int:




									"""simple docstring"""





									pass
		def 			UpperCAmelCase__       (    self		)				-> Optional[Any]:




									"""simple docstring"""





									_UpperCAmelCase	, _UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																if not model_class.supports_gradient_checkpointing:
																							continue

																_UpperCAmelCase					=    True
																_UpperCAmelCase					=    model_class(_SCREAMING_SNAKE_CASE		)
																self.assertTrue(model.is_gradient_checkpointing		)
		def 			UpperCAmelCase__       (    self		)				-> Tuple:




									"""simple docstring"""





									def check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		):
																_UpperCAmelCase					=    model_class(_SCREAMING_SNAKE_CASE		)
																model.to(_SCREAMING_SNAKE_CASE		)
																model.eval()

																with torch.no_grad():
																							_UpperCAmelCase					=    model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		)		)

																_UpperCAmelCase					=    outputs.hidden_states

																_UpperCAmelCase					=    getattr(
																    self.model_tester    ,					'expected_num_hidden_layers'    ,					self.model_tester.num_hidden_layers + 1		)
																self.assertEqual(len(_SCREAMING_SNAKE_CASE		)    ,					_SCREAMING_SNAKE_CASE		)

																self.assertListEqual(
																    list(hidden_states[0].shape[-2:]		)    ,					[self.model_tester.patch_embeds_hidden_size, self.model_tester.hidden_size]    ,					)

									_UpperCAmelCase	, _UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																_UpperCAmelCase					=    True
																check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		)

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																_UpperCAmelCase					=    True

																check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self		)				-> Dict:




									"""simple docstring"""





									_UpperCAmelCase	, _UpperCAmelCase					=    self.model_tester.prepare_config_and_inputs_for_common()

									_UpperCAmelCase					=    _config_zero_init(_SCREAMING_SNAKE_CASE		)
									for model_class in self.all_model_classes:
																_UpperCAmelCase					=    model_class(config=_SCREAMING_SNAKE_CASE		)
																for name, param in model.named_parameters():
																							if isinstance(_SCREAMING_SNAKE_CASE    ,					(nn.Linear, nn.Convad, nn.LayerNorm)		):
																														if 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'''    ,					)






		@unittest.skip(reason='Retain_grad is tested in individual model tests'		)
		def 			UpperCAmelCase__       (    self		)				-> Dict:




									"""simple docstring"""





									pass



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


							'''simple docstring'''





							_UpperCAmelCase					=    'https://i.postimg.cc/ZKwLg2Gw/367-14.png'
							_UpperCAmelCase					=    Image.open(requests.get(a__    ,						stream=a__ ).raw ).convert('RGB' )
							return im







@require_vision
@require_torch
class 	__a   (       unittest.TestCase    ):
		@slow
		def 			UpperCAmelCase__       (    self		)				-> Dict:




									"""simple docstring"""





									_UpperCAmelCase					=    'alibaba-damo/mgp-str-base'
									_UpperCAmelCase					=    MgpstrForSceneTextRecognition.from_pretrained(_SCREAMING_SNAKE_CASE		).to(_SCREAMING_SNAKE_CASE		)
									_UpperCAmelCase					=    MgpstrProcessor.from_pretrained(_SCREAMING_SNAKE_CASE		)

									_UpperCAmelCase					=    prepare_img()
									_UpperCAmelCase					=    processor(images=_SCREAMING_SNAKE_CASE    ,					return_tensors='pt'		).pixel_values.to(_SCREAMING_SNAKE_CASE		)

									# forward pass
									with torch.no_grad():
																_UpperCAmelCase					=    model(_SCREAMING_SNAKE_CASE		)

									# verify the logits
									self.assertEqual(outputs.logits[0].shape    ,					torch.Size((1, 27, 38)		)		)

									_UpperCAmelCase					=    processor.batch_decode(outputs.logits		)
									_UpperCAmelCase					=    'ticket'

									self.assertEqual(out_strs['generated_text'][0]    ,					_SCREAMING_SNAKE_CASE		)

									_UpperCAmelCase					=    torch.tensor(
									    [[[-39.5397, -44.4024, -36.1844], [-61.4709, -63.8639, -58.3454], [-74.0225, -68.5494, -71.2164]]]    ,					device=_SCREAMING_SNAKE_CASE    ,					)

									self.assertTrue(torch.allclose(outputs.logits[0][:, 1:4, 1:4]    ,					_SCREAMING_SNAKE_CASE    ,					atol=1e-4		)		)




import warnings

from .generation import GenerationMixin

class 	__a   (       UpperCAmelCase    ):
		# warning at import time
		warnings.warn(
		    'Importing `GenerationMixin` from `src/transformers/generation_utils.py` is deprecated and will '
		    'be removed in Transformers v5. Import as `from transformers import GenerationMixin` instead.'					,   UpperCAmelCase					,   )
