
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							, __UpperCamelCase							, __UpperCamelCase=False							, __UpperCamelCase=13							, __UpperCamelCase=(32, 128)							, __UpperCamelCase=4							, __UpperCamelCase=3							, __UpperCamelCase=27							, __UpperCamelCase=38							, __UpperCamelCase=99							, __UpperCamelCase=99							, __UpperCamelCase=32							, __UpperCamelCase=5							, __UpperCamelCase=4							, __UpperCamelCase=4.0							, __UpperCamelCase=257							, __UpperCamelCase=None							, ):
									_lowercase									=				parent
									_lowercase									=				is_training
									_lowercase									=				batch_size
									_lowercase									=				image_size
									_lowercase									=				patch_size
									_lowercase									=				num_channels
									_lowercase									=				max_token_length
									_lowercase									=				num_character_labels
									_lowercase									=				num_bpe_labels
									_lowercase									=				num_wordpiece_labels
									_lowercase									=				hidden_size
									_lowercase									=				num_hidden_layers
									_lowercase									=				num_attention_heads
									_lowercase									=				mlp_ratio
									_lowercase									=				patch_embeds_hidden_size
									_lowercase									=				output_hidden_states






			def       UpperCamelCase_							(			self     ):
									_lowercase									=				floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]     )
									_lowercase									=				self.get_config()
									return config, pixel_values






			def       UpperCamelCase_							(			self     ):
									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							, __UpperCamelCase							, __UpperCamelCase     ):
									_lowercase									=				MgpstrForSceneTextRecognition(__UpperCamelCase     )
									model.to(__UpperCamelCase     )
									model.eval()
									with torch.no_grad():
															_lowercase									=				model(__UpperCamelCase     )
									self.parent.assertEqual(
									    generated_ids[0][0].shape							, (self.batch_size, self.max_token_length, self.num_character_labels)     )






			def       UpperCamelCase_							(			self     ):
									_lowercase									=				self.prepare_config_and_inputs()
									_lowercase					,	_lowercase									=				config_and_inputs
									_lowercase									=				{"""pixel_values""": pixel_values}
									return config, inputs_dict







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

			a  : str				      =       False
			a  : Optional[Any]				      =       False
			a  : Any				      =       False
			a  : Tuple				      =       False






			def       UpperCamelCase_							(			self     ):
									_lowercase									=				MgpstrModelTester(self     )
									_lowercase									=				ConfigTester(self							, config_class=__UpperCamelCase							, has_text_modality=__UpperCamelCase     )






			def       UpperCamelCase_							(			self     ):
									self.config_tester.run_common_tests()






			def       UpperCamelCase_							(			self     ):
									_lowercase									=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__UpperCamelCase     )






			@unittest.skip(reason="""MgpstrModel does not use inputs_embeds"""     )
			def       UpperCamelCase_							(			self     ):
									pass






			def       UpperCamelCase_							(			self     ):
									_lowercase					,	_lowercase									=				self.model_tester.prepare_config_and_inputs_for_common()

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






			def       UpperCamelCase_							(			self     ):
									_lowercase					,	_lowercase									=				self.model_tester.prepare_config_and_inputs_for_common()

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

															_lowercase									=				["""pixel_values"""]
															self.assertListEqual(arg_names[:1]							, __UpperCamelCase     )






			@unittest.skip(reason="""MgpstrModel does not support feedforward chunking"""     )
			def       UpperCamelCase_							(			self     ):
									pass






			def       UpperCamelCase_							(			self     ):
									_lowercase					,	_lowercase									=				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

															_lowercase									=				True
															_lowercase									=				model_class(__UpperCamelCase     )
															self.assertTrue(model.is_gradient_checkpointing     )






			def       UpperCamelCase_							(			self     ):
									def check_hidden_states_output(__UpperCamelCase							, __UpperCamelCase							, __UpperCamelCase     ):
															_lowercase									=				model_class(__UpperCamelCase     )
															model.to(__UpperCamelCase     )
															model.eval()

															with torch.no_grad():
																					_lowercase									=				model(**self._prepare_for_class(__UpperCamelCase							, __UpperCamelCase     )     )

															_lowercase									=				outputs.hidden_states

															_lowercase									=				getattr(
															    self.model_tester							, """expected_num_hidden_layers"""							, self.model_tester.num_hidden_layers + 1     )
															self.assertEqual(len(__UpperCamelCase     )							, __UpperCamelCase     )

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

									_lowercase					,	_lowercase									=				self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															_lowercase									=				True
															check_hidden_states_output(__UpperCamelCase							, __UpperCamelCase							, __UpperCamelCase     )

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

															check_hidden_states_output(__UpperCamelCase							, __UpperCamelCase							, __UpperCamelCase     )






			def       UpperCamelCase_							(			self     ):
									_lowercase					,	_lowercase									=				self.model_tester.prepare_config_and_inputs_for_common()

									_lowercase									=				_config_zero_init(__UpperCamelCase     )
									for model_class in self.all_model_classes:
															_lowercase									=				model_class(config=__UpperCamelCase     )
															for name, param in model.named_parameters():
																					if isinstance(__UpperCamelCase							, (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     ):
									pass







def   UpperCamelCase__     (    )     ->    Optional[Any]:
						_lowercase									=				"""https://i.postimg.cc/ZKwLg2Gw/367-14.png"""
						_lowercase									=				Image.open(requests.get(SCREAMING_SNAKE_CASE_		,      stream=SCREAMING_SNAKE_CASE_					).raw					).convert("""RGB"""					)
						return im



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






			@slow
			def       UpperCamelCase_							(			self     ):
									_lowercase									=				"""alibaba-damo/mgp-str-base"""
									_lowercase									=				MgpstrForSceneTextRecognition.from_pretrained(__UpperCamelCase     ).to(__UpperCamelCase     )
									_lowercase									=				MgpstrProcessor.from_pretrained(__UpperCamelCase     )

									_lowercase									=				prepare_img()
									_lowercase									=				processor(images=__UpperCamelCase							, return_tensors="""pt"""     ).pixel_values.to(__UpperCamelCase     )

									# forward pass
									with torch.no_grad():
															_lowercase									=				model(__UpperCamelCase     )

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

									_lowercase									=				processor.batch_decode(outputs.logits     )
									_lowercase									=				"""ticket"""

									self.assertEqual(out_strs["""generated_text"""][0]							, __UpperCamelCase     )

									_lowercase									=				torch.tensor(
									    [[[-39.53_97, -44.40_24, -36.18_44], [-61.47_09, -63.86_39, -58.34_54], [-74.02_25, -68.54_94, -71.21_64]]]							, device=__UpperCamelCase							, )

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

import abc
import copy
import dataclasses
from dataclasses import dataclass
from typing import ClassVar, Dict, Type, TypeVar

from ..features import Features


A		:   Optional[int]         =    TypeVar('''T''', bound='''TaskTemplate''')



@dataclass(frozen=_a						)
class       a_   ( abc.ABC						):
			# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
			a  : str
			a  : ClassVar[Features]
			a  : ClassVar[Features]






			def       UpperCamelCase_							(			self							, __UpperCamelCase     ):
									return copy.deepcopy(self     )






			@property
			def       UpperCamelCase_							(			self     ):
									return Features(**self.input_schema							, **self.label_schema     )






			@property
			@abc.abstractmethod
			def       UpperCamelCase_							(			self     ):
									raise NotImplementedError






			@classmethod
			def       UpperCamelCase_							(			cls							, __UpperCamelCase     ):
									_lowercase									=				{f.name for f in dataclasses.fields(cls     )}
									return cls(**{k: v for k, v in template_dict.items() if k in field_names}     )