





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			,    __snake_case			,    __snake_case=False			,    __snake_case=1_3			,    __snake_case=(3_2, 1_2_8)			,    __snake_case=4			,    __snake_case=3			,    __snake_case=2_7			,    __snake_case=3_8			,    __snake_case=9_9			,    __snake_case=9_9			,    __snake_case=3_2			,    __snake_case=5			,    __snake_case=4			,    __snake_case=4.0			,    __snake_case=2_5_7			,    __snake_case=None			,    )   ->   Optional[Any]:


							'''simple docstring'''

							_snake_case							:       Any												= parent
							_snake_case							:       List[Any]												= is_training
							_snake_case							:       Optional[Any]												= batch_size
							_snake_case							:       Any												= image_size
							_snake_case							:       Dict												= patch_size
							_snake_case							:       str												= num_channels
							_snake_case							:       Union[str, Any]												= max_token_length
							_snake_case							:       Dict												= num_character_labels
							_snake_case							:       List[Any]												= num_bpe_labels
							_snake_case							:       str												= num_wordpiece_labels
							_snake_case							:       Any												= hidden_size
							_snake_case							:       Optional[Any]												= num_hidden_layers
							_snake_case							:       List[str]												= num_attention_heads
							_snake_case							:       List[Any]												= mlp_ratio
							_snake_case							:       Optional[Any]												= patch_embeds_hidden_size
							_snake_case							:       int												= output_hidden_states







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


							'''simple docstring'''

							_snake_case							:       Tuple												= floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]					)
							_snake_case							:       List[str]												= self.get_config()
							return config, pixel_values







		def 							lowercase							(     self					)   ->   str:


							'''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 							lowercase							(     self			,    __snake_case			,    __snake_case					)   ->   List[Any]:


							'''simple docstring'''

							_snake_case							:       List[str]												= MgpstrForSceneTextRecognition(__snake_case					)
							model.to(__snake_case					)
							model.eval()
							with torch.no_grad():
												_snake_case							:       Any												= model(__snake_case					)
							self.parent.assertEqual(
							    generated_ids[0][0].shape			,    (self.batch_size, self.max_token_length, self.num_character_labels)					)







		def 							lowercase							(     self					)   ->   int:


							'''simple docstring'''

							_snake_case							:       Optional[Any]												= self.prepare_config_and_inputs()
							_snake_case							,			_snake_case							:       Dict												= config_and_inputs
							_snake_case							:       Union[str, Any]												= {"pixel_values": pixel_values}
							return config, inputs_dict






@require_torch
class 							_a(     _UpperCAmelCase						, _UpperCAmelCase						, unittest.TestCase     ):
		lowerCamelCase__  :Any 					=		(MgpstrForSceneTextRecognition,) if is_torch_available() else ()
		lowerCamelCase__  :List[str] 					=		{"""feature-extraction""": MgpstrForSceneTextRecognition} if is_torch_available() else {}
		lowerCamelCase__  :List[Any] 					=		False

		lowerCamelCase__  :List[str] 					=		False
		lowerCamelCase__  :List[Any] 					=		False
		lowerCamelCase__  :Union[str, Any] 					=		False
		lowerCamelCase__  :Optional[Any] 					=		False







		def 							lowercase							(     self					)   ->   Tuple:


							'''simple docstring'''

							_snake_case							:       int												= MgpstrModelTester(self					)
							_snake_case							:       List[str]												= ConfigTester(self			,    config_class=__snake_case			,    has_text_modality=__snake_case					)







		def 							lowercase							(     self					)   ->   Optional[Any]:


							'''simple docstring'''

							self.config_tester.run_common_tests()







		def 							lowercase							(     self					)   ->   int:


							'''simple docstring'''

							_snake_case							:       Optional[Any]												= self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__snake_case					)







		@unittest.skip(reason="MgpstrModel does not use inputs_embeds"					)
		def 							lowercase							(     self					)   ->   str:


							'''simple docstring'''

							pass







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


							'''simple docstring'''

							_snake_case							,			_snake_case							:       Tuple												= self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_snake_case							:       Optional[int]												= model_class(__snake_case					)
												self.assertIsInstance(model.get_input_embeddings()			,    (nn.Module)					)
												_snake_case							:       Any												= model.get_output_embeddings()
												self.assertTrue(x is None or isinstance(__snake_case			,    nn.Linear					)					)







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


							'''simple docstring'''

							_snake_case							,			_snake_case							:       Any												= self.model_tester.prepare_config_and_inputs_for_common()

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

												_snake_case							:       int												= ["pixel_values"]
												self.assertListEqual(arg_names[:1]			,    __snake_case					)







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


							'''simple docstring'''

							pass







		def 							lowercase							(     self					)   ->   Tuple:


							'''simple docstring'''

							_snake_case							,			_snake_case							:       List[Any]												= 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

												_snake_case							:       Union[str, Any]												= True
												_snake_case							:       Tuple												= model_class(__snake_case					)
												self.assertTrue(model.is_gradient_checkpointing					)







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


							'''simple docstring'''

							def check_hidden_states_output(__snake_case			,    __snake_case			,    __snake_case					):
												_snake_case							:       Any												= model_class(__snake_case					)
												model.to(__snake_case					)
												model.eval()

												with torch.no_grad():
																	_snake_case							:       List[Any]												= model(**self._prepare_for_class(__snake_case			,    __snake_case					)					)

												_snake_case							:       int												= outputs.hidden_states

												_snake_case							:       List[Any]												= getattr(
												    self.model_tester			,    "expected_num_hidden_layers"			,    self.model_tester.num_hidden_layers + 1					)
												self.assertEqual(len(__snake_case					)			,    __snake_case					)

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

							_snake_case							,			_snake_case							:       Optional[int]												= self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_snake_case							:       Optional[int]												= True
												check_hidden_states_output(__snake_case			,    __snake_case			,    __snake_case					)

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

												check_hidden_states_output(__snake_case			,    __snake_case			,    __snake_case					)







		def 							lowercase							(     self					)   ->   Any:


							'''simple docstring'''

							_snake_case							,			_snake_case							:       Tuple												= self.model_tester.prepare_config_and_inputs_for_common()

							_snake_case							:       Any												= _config_zero_init(__snake_case					)
							for model_class in self.all_model_classes:
												_snake_case							:       List[str]												= model_class(config=__snake_case					)
												for name, param in model.named_parameters():
																	if isinstance(__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 							lowercase							(     self					)   ->   Optional[int]:


							'''simple docstring'''

							pass







def  A					(				):
					_snake_case							:       List[str]												= "https://i.postimg.cc/ZKwLg2Gw/367-14.png"
					_snake_case							:       Union[str, Any]												= Image.open(requests.get(lowercase__	,	stream=lowercase__					).raw					).convert("RGB"					)
					return im






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







		@slow
		def 							lowercase							(     self					)   ->   Dict:


							'''simple docstring'''

							_snake_case							:       Tuple												= "alibaba-damo/mgp-str-base"
							_snake_case							:       List[str]												= MgpstrForSceneTextRecognition.from_pretrained(__snake_case					).to(__snake_case					)
							_snake_case							:       str												= MgpstrProcessor.from_pretrained(__snake_case					)

							_snake_case							:       Optional[int]												= prepare_img()
							_snake_case							:       Optional[int]												= processor(images=__snake_case			,    return_tensors="pt"					).pixel_values.to(__snake_case					)

							# forward pass
							with torch.no_grad():
												_snake_case							:       Tuple												= model(__snake_case					)

							# verify the logits
							self.assertEqual(outputs.logits[0].shape			,    torch.Size((1, 2_7, 3_8)					)					)

							_snake_case							:       int												= processor.batch_decode(outputs.logits					)
							_snake_case							:       str												= "ticket"

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

							_snake_case							:       Dict												= 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=__snake_case			,    )

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




from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import (
			    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
			    TFXLMForMultipleChoice,
			    TFXLMForQuestionAnsweringSimple,
			    TFXLMForSequenceClassification,
			    TFXLMForTokenClassification,
			    TFXLMModel,
			    TFXLMWithLMHeadModel,
			    XLMConfig,
			)
class       _lowerCAmelCase :






			"""simple docstring"""





			def __init__(					self						:							Tuple      ,  lowercase						:							str      ,  )    ->       str:
									"""simple docstring"""







									__lowercase											=					parent
									__lowercase											=					13
									__lowercase											=					7
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					True
									__lowercase											=					False
									__lowercase											=					False
									__lowercase											=					False
									__lowercase											=					2
									__lowercase											=					99
									__lowercase											=					0
									__lowercase											=					32
									__lowercase											=					2
									__lowercase											=					4
									__lowercase											=					0.1
									__lowercase											=					0.1
									__lowercase											=					512
									__lowercase											=					16
									__lowercase											=					2
									__lowercase											=					0.02
									__lowercase											=					3
									__lowercase											=					4
									__lowercase											=					"""last"""
									__lowercase											=					True
									__lowercase											=					None
									__lowercase											=					0





			def 		snake_case__      (					self						:							Dict )    ->       Tuple:
									"""simple docstring"""







									__lowercase											=					ids_tensor([self.batch_size, self.seq_length]      ,  self.vocab_size )
									__lowercase											=					random_attention_mask([self.batch_size, self.seq_length]      ,  dtype=tf.floataa )

									__lowercase											=					None
									if self.use_input_lengths:
															__lowercase											=					(
															    ids_tensor([self.batch_size]      ,  vocab_size=2 ) + self.seq_length - 2
															)  # small variation of seq_length

									__lowercase											=					None
									if self.use_token_type_ids:
															__lowercase											=					ids_tensor([self.batch_size, self.seq_length]      ,  self.n_langs )

									__lowercase											=					None
									__lowercase											=					None
									__lowercase											=					None
									if self.use_labels:
															__lowercase											=					ids_tensor([self.batch_size]      ,  self.type_sequence_label_size )
															__lowercase											=					ids_tensor([self.batch_size, self.seq_length]      ,  self.num_labels )
															__lowercase											=					ids_tensor([self.batch_size]      ,  2      ,  dtype=tf.floataa )
															__lowercase											=					ids_tensor([self.batch_size]      ,  self.num_choices )

									__lowercase											=					XLMConfig(
									    vocab_size=self.vocab_size      ,  n_special=self.n_special      ,  emb_dim=self.hidden_size      ,  n_layers=self.num_hidden_layers      ,  n_heads=self.num_attention_heads      ,  dropout=self.hidden_dropout_prob      ,  attention_dropout=self.attention_probs_dropout_prob      ,  gelu_activation=self.gelu_activation      ,  sinusoidal_embeddings=self.sinusoidal_embeddings      ,  asm=self.asm      ,  causal=self.causal      ,  n_langs=self.n_langs      ,  max_position_embeddings=self.max_position_embeddings      ,  initializer_range=self.initializer_range      ,  summary_type=self.summary_type      ,  use_proj=self.use_proj      ,  bos_token_id=self.bos_token_id      ,  )

									return (
									    config,
									    input_ids,
									    token_type_ids,
									    input_lengths,
									    sequence_labels,
									    token_labels,
									    is_impossible_labels,
									    choice_labels,
									    input_mask,
									)





			def 		snake_case__      (					self						:							List[str]      ,  lowercase						:							Tuple      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							int      ,  lowercase						:							List[str]      ,  )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					TFXLMModel(config=lowercase )
									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
									__lowercase											=					model(lowercase )

									__lowercase											=					[input_ids, input_mask]
									__lowercase											=					model(lowercase )
									self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size) )





			def 		snake_case__      (					self						:							Dict      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Dict      ,  lowercase						:							Dict      ,  lowercase						:							int      ,  lowercase						:							Union[str, Any]      ,  )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					TFXLMWithLMHeadModel(lowercase )

									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
									__lowercase											=					model(lowercase )

									__lowercase											=					outputs

									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.vocab_size) )





			def 		snake_case__      (					self						:							Optional[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Any      ,  lowercase						:							int      ,  lowercase						:							List[Any]      ,  lowercase						:							Any      ,  lowercase						:							int      ,  lowercase						:							List[Any]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[Any]      ,  )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					TFXLMForQuestionAnsweringSimple(lowercase )

									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths}

									__lowercase											=					model(lowercase )

									self.parent.assertEqual(result.start_logits.shape      ,  (self.batch_size, self.seq_length) )
									self.parent.assertEqual(result.end_logits.shape      ,  (self.batch_size, self.seq_length) )





			def 		snake_case__      (					self						:							Optional[int]      ,  lowercase						:							Tuple      ,  lowercase						:							List[str]      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Any      ,  lowercase						:							Tuple      ,  lowercase						:							Any      ,  lowercase						:							Dict      ,  )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					TFXLMForSequenceClassification(lowercase )

									__lowercase											=					{"""input_ids""": input_ids, """lengths""": input_lengths}

									__lowercase											=					model(lowercase )

									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.type_sequence_label_size) )





			def 		snake_case__      (					self						:							Union[str, Any]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[int]      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Tuple      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Tuple      ,  lowercase						:							List[Any]      ,  lowercase						:							Optional[Any]      ,  )    ->       int:
									"""simple docstring"""







									__lowercase											=					self.num_labels
									__lowercase											=					TFXLMForTokenClassification(config=lowercase )
									__lowercase											=					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
									__lowercase											=					model(lowercase )
									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.num_labels) )





			def 		snake_case__      (					self						:							int      ,  lowercase						:							Tuple      ,  lowercase						:							Optional[Any]      ,  lowercase						:							str      ,  lowercase						:							str      ,  lowercase						:							Dict      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							List[str]      ,  lowercase						:							List[str]      ,  )    ->       List[str]:
									"""simple docstring"""







									__lowercase											=					self.num_choices
									__lowercase											=					TFXLMForMultipleChoice(config=lowercase )
									__lowercase											=					tf.tile(tf.expand_dims(lowercase      ,  1 )      ,  (1, self.num_choices, 1) )
									__lowercase											=					tf.tile(tf.expand_dims(lowercase      ,  1 )      ,  (1, self.num_choices, 1) )
									__lowercase											=					tf.tile(tf.expand_dims(lowercase      ,  1 )      ,  (1, self.num_choices, 1) )
									__lowercase											=					{
									    """input_ids""": multiple_choice_inputs_ids,
									    """attention_mask""": multiple_choice_input_mask,
									    """token_type_ids""": multiple_choice_token_type_ids,
									}
									__lowercase											=					model(lowercase )
									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_choices) )







			def 		snake_case__      (					self						:							str )    ->       Optional[int]:
									"""simple docstring"""







									__lowercase											=					self.prepare_config_and_inputs()
									(
									    (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      (
									    __lowercase
									)						,      
									)											=					config_and_inputs
									__lowercase											=					{
									    """input_ids""": input_ids,
									    """token_type_ids""": token_type_ids,
									    """langs""": token_type_ids,
									    """lengths""": input_lengths,
									}
									return config, inputs_dict





@require_tf
class       _lowerCAmelCase (			_UpperCAmelCase     ,       _UpperCAmelCase     ,       unittest.TestCase      ):






			"""simple docstring"""





			lowercase__   :	Tuple  			=      (
			    (
			        TFXLMModel,
			        TFXLMWithLMHeadModel,
			        TFXLMForSequenceClassification,
			        TFXLMForQuestionAnsweringSimple,
			        TFXLMForTokenClassification,
			        TFXLMForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			lowercase__   :	List[str]  			=      (
			    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
			)  # TODO (PVP): Check other models whether language generation is also applicable
			lowercase__   :	Tuple  			=      (
			    {
			        """feature-extraction""": TFXLMModel,
			        """fill-mask""": TFXLMWithLMHeadModel,
			        """question-answering""": TFXLMForQuestionAnsweringSimple,
			        """text-classification""": TFXLMForSequenceClassification,
			        """text-generation""": TFXLMWithLMHeadModel,
			        """token-classification""": TFXLMForTokenClassification,
			        """zero-shot""": TFXLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			lowercase__   :	int  			=      False
			lowercase__   :	int  			=      False





			def 		snake_case__      (					self						:							Optional[int]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							List[str]      ,  lowercase						:							Dict )    ->       str:
									"""simple docstring"""







									if (
									    pipeline_test_casse_name == "QAPipelineTests"
									    and tokenizer_name is not None
									    and not tokenizer_name.endswith("""Fast""" )
									):
															# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
															# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
															# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
															return True

									return False





			def 		snake_case__      (					self						:							Tuple )    ->       List[str]:
									"""simple docstring"""







									__lowercase											=					TFXLMModelTester(self )
									__lowercase											=					ConfigTester(self      ,  config_class=lowercase      ,  emb_dim=37 )





			def 		snake_case__      (					self						:							List[str] )    ->       List[str]:
									"""simple docstring"""







									self.config_tester.run_common_tests()





			def 		snake_case__      (					self						:							List[Any] )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_model(*lowercase )





			def 		snake_case__      (					self						:							str )    ->       str:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_lm_head(*lowercase )





			def 		snake_case__      (					self						:							Optional[int] )    ->       Optional[int]:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_qa(*lowercase )





			def 		snake_case__      (					self						:							Optional[Any] )    ->       str:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_sequence_classif(*lowercase )





			def 		snake_case__      (					self						:							Union[str, Any] )    ->       int:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_for_token_classification(*lowercase )





			def 		snake_case__      (					self						:							Optional[Any] )    ->       Tuple:
									"""simple docstring"""







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_for_multiple_choice(*lowercase )







			@slow
			def 		snake_case__      (					self						:							Optional[int] )    ->       Optional[int]:
									"""simple docstring"""







									for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															__lowercase											=					TFXLMModel.from_pretrained(lowercase )
															self.assertIsNotNone(lowercase )





@require_tf
class       _lowerCAmelCase (			unittest.TestCase      ):






			"""simple docstring"""





			@slow
			def 		snake_case__      (					self						:							int )    ->       List[Any]:
									"""simple docstring"""







									__lowercase											=					TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048""" )
									__lowercase											=					tf.convert_to_tensor([[14, 447]]      ,  dtype=tf.intaa )  # the president
									__lowercase											=					[
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									    14,
									    447,
									]  # the president the president the president the president the president the president the president the president the president the president
									# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
									__lowercase											=					model.generate(lowercase      ,  do_sample=lowercase )
									self.assertListEqual(output_ids[0].numpy().tolist()      ,  lowercase )





