






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




						def __init__(    self		,	lowercase		,	lowercase=False		,	lowercase=13		,	lowercase=(32, 128)		,	lowercase=4		,	lowercase=3		,	lowercase=27		,	lowercase=38		,	lowercase=99		,	lowercase=99		,	lowercase=32		,	lowercase=5		,	lowercase=4		,	lowercase=4.0		,	lowercase=257		,	lowercase=None		,	)			->						int:
													_a  :    Union[str, Any]			=						parent
													_a  :    List[Any]			=						is_training
													_a  :    Dict			=						batch_size
													_a  :    List[str]			=						image_size
													_a  :    Any			=						patch_size
													_a  :    Dict			=						num_channels
													_a  :    Tuple			=						max_token_length
													_a  :    Union[str, Any]			=						num_character_labels
													_a  :    str			=						num_bpe_labels
													_a  :    Optional[Any]			=						num_wordpiece_labels
													_a  :    List[str]			=						hidden_size
													_a  :    List[str]			=						num_hidden_layers
													_a  :    str			=						num_attention_heads
													_a  :    List[str]			=						mlp_ratio
													_a  :    str			=						patch_embeds_hidden_size
													_a  :    Any			=						output_hidden_states




						def      snake_case__(    self       )			->						List[str]:
													_a  :    Dict			=						floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]       )
													_a  :    Any			=						self.get_config()
													return config, pixel_values




						def      snake_case__(    self       )			->						str:
													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      snake_case__(    self		,	lowercase		,	lowercase       )			->						Tuple:
													_a  :    str			=						MgpstrForSceneTextRecognition(_lowerCamelCase       )
													model.to(_lowerCamelCase       )
													model.eval()
													with torch.no_grad():
																				_a  :    List[str]			=						model(_lowerCamelCase       )
													self.parent.assertEqual(
													    generated_ids[0][0].shape		,	(self.batch_size, self.max_token_length, self.num_character_labels)       )







						def      snake_case__(    self       )			->						Optional[int]:
													_a  :    List[str]			=						self.prepare_config_and_inputs()
													_a  :    Optional[Any]			=						config_and_inputs
													_a  :    Union[str, Any]			=						{"pixel_values": pixel_values}
													return config, inputs_dict

@require_torch
class      UpperCamelCase_							(				UpperCamelCase ,       UpperCamelCase ,       unittest.TestCase       ):
						lowercase									=  (MgpstrForSceneTextRecognition,) if is_torch_available() else ()
						lowercase									=  {"""feature-extraction""": MgpstrForSceneTextRecognition} if is_torch_available() else {}
						lowercase									=  False

						lowercase									=  False
						lowercase									=  False
						lowercase									=  False
						lowercase									=  False




						def      snake_case__(    self       )			->						List[Any]:
													_a  :    Optional[Any]			=						MgpstrModelTester(self       )
													_a  :    int			=						ConfigTester(self		,	config_class=_lowerCamelCase		,	has_text_modality=_lowerCamelCase       )




						def      snake_case__(    self       )			->						str:
													self.config_tester.run_common_tests()




						def      snake_case__(    self       )			->						int:
													_a  :    Tuple			=						self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*_lowerCamelCase       )




						@unittest.skip(reason='''MgpstrModel does not use inputs_embeds'''       )
						def      snake_case__(    self       )			->						List[Any]:
													pass




						def      snake_case__(    self       )			->						Union[str, Any]:
													_a  :    Dict			=						self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				_a  :    List[Any]			=						model_class(_lowerCamelCase       )
																				self.assertIsInstance(model.get_input_embeddings()		,	(nn.Module)       )
																				_a  :    Tuple			=						model.get_output_embeddings()
																				self.assertTrue(x is None or isinstance(_lowerCamelCase		,	nn.Linear       )       )




						def      snake_case__(    self       )			->						Optional[Any]:
													_a  :    List[Any]			=						self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				_a  :    Union[str, Any]			=						model_class(_lowerCamelCase       )
																				_a  :    int			=						inspect.signature(model.forward       )
																				# signature.parameters is an OrderedDict => so arg_names order is deterministic
																				_a  :    Optional[int]			=						[*signature.parameters.keys()]

																				_a  :    List[Any]			=						["pixel_values"]
																				self.assertListEqual(arg_names[:1]		,	_lowerCamelCase       )




						@unittest.skip(reason='''MgpstrModel does not support feedforward chunking'''       )
						def      snake_case__(    self       )			->						List[str]:
													pass




						def      snake_case__(    self       )			->						Union[str, Any]:
													_a  :    Dict			=						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

																				_a  :    int			=						True
																				_a  :    Tuple			=						model_class(_lowerCamelCase       )
																				self.assertTrue(model.is_gradient_checkpointing       )




						def      snake_case__(    self       )			->						Any:
													def check_hidden_states_output(lowercase		,	lowercase		,	lowercase       ):
																				_a  :    Optional[Any]			=						model_class(_lowerCamelCase       )
																				model.to(_lowerCamelCase       )
																				model.eval()

																				with torch.no_grad():
																											_a  :    List[str]			=						model(**self._prepare_for_class(_lowerCamelCase		,	_lowerCamelCase       )       )

																				_a  :    List[str]			=						outputs.hidden_states

																				_a  :    List[str]			=						getattr(
																				    self.model_tester		,	'''expected_num_hidden_layers'''		,	self.model_tester.num_hidden_layers + 1       )
																				self.assertEqual(len(_lowerCamelCase       )		,	_lowerCamelCase       )

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

													_a  :    str			=						self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				_a  :    str			=						True
																				check_hidden_states_output(_lowerCamelCase		,	_lowerCamelCase		,	_lowerCamelCase       )

																				# check that output_hidden_states also work using config
																				del inputs_dict["output_hidden_states"]
																				_a  :    Any			=						True

																				check_hidden_states_output(_lowerCamelCase		,	_lowerCamelCase		,	_lowerCamelCase       )




						def      snake_case__(    self       )			->						int:
													_a  :    Dict			=						self.model_tester.prepare_config_and_inputs_for_common()

													_a  :    List[Any]			=						_config_zero_init(_lowerCamelCase       )
													for model_class in self.all_model_classes:
																				_a  :    Optional[Any]			=						model_class(config=_lowerCamelCase       )
																				for name, param in model.named_parameters():
																											if isinstance(_lowerCamelCase		,	(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      snake_case__(    self       )			->						Union[str, Any]:
													pass






def    UpperCamelCase__  (   )     ->		Any:







							"""simple docstring"""





							_a  :    Dict			=						"https://i.postimg.cc/ZKwLg2Gw/367-14.png"
							_a  :    int			=						Image.open(requests.get(_SCREAMING_SNAKE_CASE    ,	stream=_SCREAMING_SNAKE_CASE     ).raw     ).convert('''RGB'''     )
							return im







@require_vision
@require_torch
class      UpperCamelCase_							(				unittest.TestCase       ):




						@slow
						def      snake_case__(    self       )			->						Tuple:
													_a  :    List[Any]			=						"alibaba-damo/mgp-str-base"
													_a  :    Optional[Any]			=						MgpstrForSceneTextRecognition.from_pretrained(_lowerCamelCase       ).to(_lowerCamelCase       )
													_a  :    str			=						MgpstrProcessor.from_pretrained(_lowerCamelCase       )

													_a  :    str			=						prepare_img()
													_a  :    int			=						processor(images=_lowerCamelCase		,	return_tensors='''pt'''       ).pixel_values.to(_lowerCamelCase       )

													# forward pass
													with torch.no_grad():
																				_a  :    List[Any]			=						model(_lowerCamelCase       )

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

													_a  :    List[Any]			=						processor.batch_decode(outputs.logits       )
													_a  :    Any			=						"ticket"

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

													_a  :    List[Any]			=						torch.tensor(
													    [[[-39.5397, -44.4024, -36.1844], [-61.4709, -63.8639, -58.3454], [-74.0225, -68.5494, -71.2164]]]		,	device=_lowerCamelCase		,	)

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

import unittest
from pathlib import Path

from transformers import is_vision_available, load_tool
from transformers.testing_utils import get_tests_dir

from .test_tools_common import ToolTesterMixin


if is_vision_available():
				from PIL import Image
class    _UpperCamelCase(   unittest.TestCase		,						SCREAMING_SNAKE_CASE				):

						def 						a__ (					self		:			Optional[int]			):
													_UpperCAmelCase  :			Any	       =		load_tool("image-captioning"			)
													self.tool.setup()
													_UpperCAmelCase  :			Optional[Any]	       =		load_tool("image-captioning"	,						remote=_lowerCamelCase			)

						def 						a__ (					self		:			int			):
													_UpperCAmelCase  :			Optional[int]	       =		Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"			)			) / "000000039769.png"			)
													_UpperCAmelCase  :			Optional[int]	       =		self.tool(_lowerCamelCase			)
													self.assertEqual(_lowerCamelCase	,						"two cats sleeping on a couch"			)

						def 						a__ (					self		:			str			):
													_UpperCAmelCase  :			List[str]	       =		Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"			)			) / "000000039769.png"			)
													_UpperCAmelCase  :			Optional[Any]	       =		self.remote_tool(_lowerCamelCase			)
													self.assertEqual(_lowerCamelCase	,						"two cats sleeping on a couch"			)

						def 						a__ (					self		:			Union[str, Any]			):
													_UpperCAmelCase  :			Any	       =		Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"			)			) / "000000039769.png"			)
													_UpperCAmelCase  :			Union[str, Any]	       =		self.tool(image=_lowerCamelCase			)
													self.assertEqual(_lowerCamelCase	,						"two cats sleeping on a couch"			)






						def 						a__ (					self		:			Optional[int]			):
													_UpperCAmelCase  :			str	       =		Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"			)			) / "000000039769.png"			)
													_UpperCAmelCase  :			str	       =		self.remote_tool(image=_lowerCamelCase			)
													self.assertEqual(_lowerCamelCase	,						"two cats sleeping on a couch"			)




