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




							'''simple docstring'''

							def __init__(				self     ,						UpperCamelCase     ,						) ->	Union[str, Any]:
										UpperCamelCase__    :		str     =				parent
										UpperCamelCase__    :		Tuple     =				13
										UpperCamelCase__    :		List[str]     =				7
										UpperCamelCase__    :		int     =				True
										UpperCamelCase__    :		List[Any]     =				True
										UpperCamelCase__    :		Optional[Any]     =				True
										UpperCamelCase__    :		Dict     =				True
										UpperCamelCase__    :		Dict     =				True
										UpperCamelCase__    :		Dict     =				False
										UpperCamelCase__    :		Dict     =				False
										UpperCamelCase__    :		Union[str, Any]     =				False
										UpperCamelCase__    :		Optional[int]     =				2
										UpperCamelCase__    :		Any     =				99
										UpperCamelCase__    :		List[str]     =				0
										UpperCamelCase__    :		List[Any]     =				32
										UpperCamelCase__    :		Union[str, Any]     =				2
										UpperCamelCase__    :		Optional[Any]     =				4
										UpperCamelCase__    :		Optional[int]     =				0.1
										UpperCamelCase__    :		Dict     =				0.1
										UpperCamelCase__    :		List[str]     =				5_12
										UpperCamelCase__    :		str     =				16
										UpperCamelCase__    :		Any     =				2
										UpperCamelCase__    :		Optional[int]     =				0.02
										UpperCamelCase__    :		int     =				3
										UpperCamelCase__    :		int     =				4
										UpperCamelCase__    :		Optional[int]     =				'last'
										UpperCamelCase__    :		List[str]     =				True
										UpperCamelCase__    :		str     =				None
										UpperCamelCase__    :		str     =				0
							def        lowerCAmelCase__ (				self) ->	List[Any]:
										UpperCamelCase__    :		int     =				ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size)
										UpperCamelCase__    :		Dict     =				random_attention_mask([self.batch_size, self.seq_length]     ,						dtype=tf.floataa)

										UpperCamelCase__    :		Union[str, Any]     =				None
										if self.use_input_lengths:
													UpperCamelCase__    :		Optional[int]     =				(
													    ids_tensor([self.batch_size]     ,						vocab_size=2) + self.seq_length - 2
													)  # small variation of seq_length

										UpperCamelCase__    :		Union[str, Any]     =				None
										if self.use_token_type_ids:
													UpperCamelCase__    :		Dict     =				ids_tensor([self.batch_size, self.seq_length]     ,						self.n_langs)

										UpperCamelCase__    :		Dict     =				None
										UpperCamelCase__    :		List[Any]     =				None
										UpperCamelCase__    :		Any     =				None
										if self.use_labels:
													UpperCamelCase__    :		int     =				ids_tensor([self.batch_size]     ,						self.type_sequence_label_size)
													UpperCamelCase__    :		Tuple     =				ids_tensor([self.batch_size, self.seq_length]     ,						self.num_labels)
													UpperCamelCase__    :		List[str]     =				ids_tensor([self.batch_size]     ,						2     ,						dtype=tf.floataa)
													UpperCamelCase__    :		Dict     =				ids_tensor([self.batch_size]     ,						self.num_choices)

										UpperCamelCase__    :		Optional[int]     =				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        lowerCAmelCase__ (				self     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						) ->	Union[str, Any]:
										UpperCamelCase__    :		List[str]     =				TFXLMModel(config=UpperCamelCase)
										UpperCamelCase__    :		int     =				{'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
										UpperCamelCase__    :		Union[str, Any]     =				model(UpperCamelCase)

										UpperCamelCase__    :		Optional[Any]     =				[input_ids, input_mask]
										UpperCamelCase__    :		Union[str, Any]     =				model(UpperCamelCase)
										self.parent.assertEqual(result.last_hidden_state.shape     ,						(self.batch_size, self.seq_length, self.hidden_size))
							def        lowerCAmelCase__ (				self     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						) ->	Dict:
										UpperCamelCase__    :		Optional[int]     =				TFXLMWithLMHeadModel(UpperCamelCase)

										UpperCamelCase__    :		Any     =				{'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
										UpperCamelCase__    :		Any     =				model(UpperCamelCase)

										UpperCamelCase__    :		Tuple     =				outputs

										self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.vocab_size))
							def        lowerCAmelCase__ (				self     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						) ->	Any:
										UpperCamelCase__    :		Optional[Any]     =				TFXLMForQuestionAnsweringSimple(UpperCamelCase)

										UpperCamelCase__    :		int     =				{'input_ids': input_ids, 'lengths': input_lengths}

										UpperCamelCase__    :		List[str]     =				model(UpperCamelCase)

										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        lowerCAmelCase__ (				self     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						) ->	Optional[int]:
										UpperCamelCase__    :		Tuple     =				TFXLMForSequenceClassification(UpperCamelCase)

										UpperCamelCase__    :		Dict     =				{'input_ids': input_ids, 'lengths': input_lengths}

										UpperCamelCase__    :		Union[str, Any]     =				model(UpperCamelCase)

										self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.type_sequence_label_size))
							def        lowerCAmelCase__ (				self     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						) ->	Optional[Any]:
										UpperCamelCase__    :		Union[str, Any]     =				self.num_labels
										UpperCamelCase__    :		Dict     =				TFXLMForTokenClassification(config=UpperCamelCase)
										UpperCamelCase__    :		Union[str, Any]     =				{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
										UpperCamelCase__    :		str     =				model(UpperCamelCase)
										self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.num_labels))
							def        lowerCAmelCase__ (				self     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						) ->	Any:
										UpperCamelCase__    :		Any     =				self.num_choices
										UpperCamelCase__    :		Dict     =				TFXLMForMultipleChoice(config=UpperCamelCase)
										UpperCamelCase__    :		Union[str, Any]     =				tf.tile(tf.expand_dims(UpperCamelCase     ,						1)     ,						(1, self.num_choices, 1))
										UpperCamelCase__    :		Optional[int]     =				tf.tile(tf.expand_dims(UpperCamelCase     ,						1)     ,						(1, self.num_choices, 1))
										UpperCamelCase__    :		Any     =				tf.tile(tf.expand_dims(UpperCamelCase     ,						1)     ,						(1, self.num_choices, 1))
										UpperCamelCase__    :		Any     =				{
										    'input_ids': multiple_choice_inputs_ids,
										    'attention_mask': multiple_choice_input_mask,
										    'token_type_ids': multiple_choice_token_type_ids,
										}
										UpperCamelCase__    :		List[str]     =				model(UpperCamelCase)
										self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_choices))






							def        lowerCAmelCase__ (				self) ->	List[Any]:
										UpperCamelCase__    :		Tuple     =				self.prepare_config_and_inputs()
										(
										    (
										    UpperCamelCase__
										)   ,			(
										    UpperCamelCase__
										)   ,			(
										    UpperCamelCase__
										)   ,			(
										    UpperCamelCase__
										)   ,			(
										    UpperCamelCase__
										)   ,			(
										    UpperCamelCase__
										)   ,			(
										    UpperCamelCase__
										)   ,			(
										    UpperCamelCase__
										)   ,			(
										    UpperCamelCase__
										)   ,			
										)    :		List[str]     =				config_and_inputs
										UpperCamelCase__    :		Union[str, Any]     =				{
										    'input_ids': input_ids,
										    'token_type_ids': token_type_ids,
										    'langs': token_type_ids,
										    'lengths': input_lengths,
										}
										return config, inputs_dict



@require_tf
class 			UpperCamelCase_			(						__UpperCamelCase	,     __UpperCamelCase	,     unittest.TestCase   ):




							'''simple docstring'''

							UpperCamelCase_					   =							(
							    (
							        TFXLMModel,
							        TFXLMWithLMHeadModel,
							        TFXLMForSequenceClassification,
							        TFXLMForQuestionAnsweringSimple,
							        TFXLMForTokenClassification,
							        TFXLMForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							UpperCamelCase_					   =							(
							    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
							)  # TODO (PVP): Check other models whether language generation is also applicable
							UpperCamelCase_					   =							(
							    {
							        """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 {}
							)
							UpperCamelCase_					   =							False
							UpperCamelCase_					   =							False
							def        lowerCAmelCase__ (				self     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase     ,						UpperCamelCase) ->	Union[str, Any]:
										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        lowerCAmelCase__ (				self) ->	str:
										UpperCamelCase__    :		Dict     =				TFXLMModelTester(self)
										UpperCamelCase__    :		Dict     =				ConfigTester(self     ,						config_class=UpperCamelCase     ,						emb_dim=37)
							def        lowerCAmelCase__ (				self) ->	int:
										self.config_tester.run_common_tests()
							def        lowerCAmelCase__ (				self) ->	Tuple:
										UpperCamelCase__    :		Dict     =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_model(*UpperCamelCase)
							def        lowerCAmelCase__ (				self) ->	Tuple:
										UpperCamelCase__    :		str     =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_lm_head(*UpperCamelCase)
							def        lowerCAmelCase__ (				self) ->	str:
										UpperCamelCase__    :		Dict     =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_qa(*UpperCamelCase)
							def        lowerCAmelCase__ (				self) ->	Optional[int]:
										UpperCamelCase__    :		Dict     =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_sequence_classif(*UpperCamelCase)
							def        lowerCAmelCase__ (				self) ->	Union[str, Any]:
										UpperCamelCase__    :		List[str]     =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_token_classification(*UpperCamelCase)
							def        lowerCAmelCase__ (				self) ->	int:
										UpperCamelCase__    :		Optional[int]     =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCamelCase)






							@slow
							def        lowerCAmelCase__ (				self) ->	List[Any]:
										for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCamelCase__    :		int     =				TFXLMModel.from_pretrained(UpperCamelCase)
													self.assertIsNotNone(UpperCamelCase)



@require_tf
class 			UpperCamelCase_			(						unittest.TestCase   ):




							'''simple docstring'''

							@slow
							def        lowerCAmelCase__ (				self) ->	Tuple:
										UpperCamelCase__    :		Union[str, Any]     =				TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048')
										UpperCamelCase__    :		Optional[Any]     =				tf.convert_to_tensor([[14, 4_47]]     ,						dtype=tf.intaa)  # the president
										UpperCamelCase__    :		Any     =				[
										    14,
										    4_47,
										    14,
										    4_47,
										    14,
										    4_47,
										    14,
										    4_47,
										    14,
										    4_47,
										    14,
										    4_47,
										    14,
										    4_47,
										    14,
										    4_47,
										    14,
										    4_47,
										    14,
										    4_47,
										]  # 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
										UpperCamelCase__    :		Any     =				model.generate(UpperCamelCase     ,						do_sample=UpperCamelCase)
										self.assertListEqual(output_ids[0].numpy().tolist()     ,						UpperCamelCase)





from __future__ import annotations

import re



def       _lowercase					(      __SCREAMING_SNAKE_CASE )	->     list[str]:

			def alphanum_key(__SCREAMING_SNAKE_CASE ):
						return [int(__SCREAMING_SNAKE_CASE ) if s.isdigit() else s.lower() for s in re.split('([0-9]+)'				,    __SCREAMING_SNAKE_CASE )]

			return sorted(__SCREAMING_SNAKE_CASE				,    key=__SCREAMING_SNAKE_CASE )


if __name__ == "__main__":
							import doctest

							doctest.testmod()



