


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




	def __init__(   self		:						Tuple						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]						,   )->			Dict:
			lowerCAmelCase__  :     Dict       	=   parent
			lowerCAmelCase__  :     Tuple       	=   13
			lowerCAmelCase__  :     Dict       	=   7
			lowerCAmelCase__  :     str       	=   True
			lowerCAmelCase__  :     str       	=   True
			lowerCAmelCase__  :     str       	=   True
			lowerCAmelCase__  :     Optional[Any]       	=   True
			lowerCAmelCase__  :     Optional[int]       	=   True
			lowerCAmelCase__  :     Union[str, Any]       	=   False
			lowerCAmelCase__  :     Union[str, Any]       	=   False
			lowerCAmelCase__  :     str       	=   False
			lowerCAmelCase__  :     str       	=   2
			lowerCAmelCase__  :     int       	=   99
			lowerCAmelCase__  :     Any       	=   0
			lowerCAmelCase__  :     Optional[Any]       	=   32
			lowerCAmelCase__  :     Union[str, Any]       	=   2
			lowerCAmelCase__  :     Optional[Any]       	=   4
			lowerCAmelCase__  :     int       	=   0.1
			lowerCAmelCase__  :     Any       	=   0.1
			lowerCAmelCase__  :     Optional[int]       	=   512
			lowerCAmelCase__  :     Union[str, Any]       	=   16
			lowerCAmelCase__  :     Union[str, Any]       	=   2
			lowerCAmelCase__  :     Tuple       	=   0.02
			lowerCAmelCase__  :     int       	=   3
			lowerCAmelCase__  :     Optional[int]       	=   4
			lowerCAmelCase__  :     Any       	=   '''last'''
			lowerCAmelCase__  :     Any       	=   True
			lowerCAmelCase__  :     List[Any]       	=   None
			lowerCAmelCase__  :     Optional[int]       	=   0




	def 				UpperCAmelCase__(   self		:						Dict						)->			Optional[Any]:
			lowerCAmelCase__  :     Any       	=   ids_tensor([self.batch_size, self.seq_length]						,   self.vocab_size						)
			lowerCAmelCase__  :     Union[str, Any]       	=   random_attention_mask([self.batch_size, self.seq_length]						,   dtype=tf.floataa						)

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

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

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

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

			lowerCAmelCase__  :     Tuple       	=   [input_ids, input_mask]
			lowerCAmelCase__  :     Optional[Any]       	=   model(_SCREAMING_SNAKE_CASE						)
			self.parent.assertEqual(result.last_hidden_state.shape						,   (self.batch_size, self.seq_length, self.hidden_size)						)




	def 				UpperCAmelCase__(   self		:						Optional[int]						,   _SCREAMING_SNAKE_CASE		:						List[Any]						,   _SCREAMING_SNAKE_CASE		:						str						,   _SCREAMING_SNAKE_CASE		:						List[Any]						,   _SCREAMING_SNAKE_CASE		:						str						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]						,   _SCREAMING_SNAKE_CASE		:						Optional[int]						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						List[Any]						,   _SCREAMING_SNAKE_CASE		:						Any						,   )->			Union[str, Any]:
			lowerCAmelCase__  :     Union[str, Any]       	=   TFXLMWithLMHeadModel(_SCREAMING_SNAKE_CASE						)

			lowerCAmelCase__  :     str       	=   {'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
			lowerCAmelCase__  :     Optional[int]       	=   model(_SCREAMING_SNAKE_CASE						)

			lowerCAmelCase__  :     List[str]       	=   outputs

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




	def 				UpperCAmelCase__(   self		:						str						,   _SCREAMING_SNAKE_CASE		:						Union[str, Any]						,   _SCREAMING_SNAKE_CASE		:						Union[str, Any]						,   _SCREAMING_SNAKE_CASE		:						str						,   _SCREAMING_SNAKE_CASE		:						Dict						,   _SCREAMING_SNAKE_CASE		:						Optional[int]						,   _SCREAMING_SNAKE_CASE		:						str						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						Tuple						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]						,   )->			Dict:
			lowerCAmelCase__  :     Dict       	=   TFXLMForQuestionAnsweringSimple(_SCREAMING_SNAKE_CASE						)

			lowerCAmelCase__  :     Optional[int]       	=   {'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase__  :     List[Any]       	=   model(_SCREAMING_SNAKE_CASE						)

			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 				UpperCAmelCase__(   self		:						Dict						,   _SCREAMING_SNAKE_CASE		:						str						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						str						,   _SCREAMING_SNAKE_CASE		:						Tuple						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						List[Any]						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						Tuple						,   _SCREAMING_SNAKE_CASE		:						Optional[int]						,   )->			int:
			lowerCAmelCase__  :     List[str]       	=   TFXLMForSequenceClassification(_SCREAMING_SNAKE_CASE						)

			lowerCAmelCase__  :     List[str]       	=   {'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase__  :     Optional[int]       	=   model(_SCREAMING_SNAKE_CASE						)

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




	def 				UpperCAmelCase__(   self		:						Tuple						,   _SCREAMING_SNAKE_CASE		:						Any						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						Optional[int]						,   _SCREAMING_SNAKE_CASE		:						str						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]						,   _SCREAMING_SNAKE_CASE		:						List[Any]						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]						,   )->			List[str]:
			lowerCAmelCase__  :     Optional[int]       	=   self.num_labels
			lowerCAmelCase__  :     Any       	=   TFXLMForTokenClassification(config=_SCREAMING_SNAKE_CASE						)
			lowerCAmelCase__  :     Dict       	=   {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
			lowerCAmelCase__  :     Optional[Any]       	=   model(_SCREAMING_SNAKE_CASE						)
			self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.seq_length, self.num_labels)						)




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




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





@require_tf
class    _a				(							_lowercase	,		_lowercase	,		unittest.TestCase):
	_a    :    Dict        =				(
	    (
	        TFXLMModel,
	        TFXLMWithLMHeadModel,
	        TFXLMForSequenceClassification,
	        TFXLMForQuestionAnsweringSimple,
	        TFXLMForTokenClassification,
	        TFXLMForMultipleChoice,
	    )
	    if is_tf_available()
	    else ()
	)
	_a    :    Any        =				(
	    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	_a    :    Dict        =				(
	    {
	        '''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 {}
	)
	_a    :    List[Any]        =				False
	_a    :    Union[str, Any]        =				False




	def 				UpperCAmelCase__(   self		:						Dict						,   _SCREAMING_SNAKE_CASE		:						List[str]						,   _SCREAMING_SNAKE_CASE		:						Dict						,   _SCREAMING_SNAKE_CASE		:						Optional[Any]						,   _SCREAMING_SNAKE_CASE		:						Union[str, Any]						,   _SCREAMING_SNAKE_CASE		:						List[Any]						)->			str:
			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 				UpperCAmelCase__(   self		:						List[Any]						)->			Any:
			lowerCAmelCase__  :     List[Any]       	=   TFXLMModelTester(self						)
			lowerCAmelCase__  :     Dict       	=   ConfigTester(self						,   config_class=_SCREAMING_SNAKE_CASE						,   emb_dim=37						)




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




	def 				UpperCAmelCase__(   self		:						Tuple						)->			str:
			lowerCAmelCase__  :     Optional[Any]       	=   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_model(*_SCREAMING_SNAKE_CASE						)




	def 				UpperCAmelCase__(   self		:						List[Any]						)->			Optional[Any]:
			lowerCAmelCase__  :     Optional[Any]       	=   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_lm_head(*_SCREAMING_SNAKE_CASE						)




	def 				UpperCAmelCase__(   self		:						Dict						)->			int:
			lowerCAmelCase__  :     Optional[Any]       	=   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_qa(*_SCREAMING_SNAKE_CASE						)




	def 				UpperCAmelCase__(   self		:						Dict						)->			int:
			lowerCAmelCase__  :     Tuple       	=   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_sequence_classif(*_SCREAMING_SNAKE_CASE						)




	def 				UpperCAmelCase__(   self		:						Tuple						)->			Any:
			lowerCAmelCase__  :     Optional[Any]       	=   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_token_classification(*_SCREAMING_SNAKE_CASE						)




	def 				UpperCAmelCase__(   self		:						Optional[Any]						)->			int:
			lowerCAmelCase__  :     Optional[Any]       	=   self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_multiple_choice(*_SCREAMING_SNAKE_CASE						)




	@slow
	def 				UpperCAmelCase__(   self		:						Dict						)->			Union[str, Any]:
			for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowerCAmelCase__  :     Dict       	=   TFXLMModel.from_pretrained(_SCREAMING_SNAKE_CASE						)
					self.assertIsNotNone(_SCREAMING_SNAKE_CASE						)





@require_tf
class    _a				(							unittest.TestCase):




	@slow
	def 				UpperCAmelCase__(   self		:						Dict						)->			List[str]:
			lowerCAmelCase__  :     Optional[int]       	=   TFXLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''						)
			lowerCAmelCase__  :     Optional[int]       	=   tf.convert_to_tensor([[14, 447]]						,   dtype=tf.intaa						)  # the president
			lowerCAmelCase__  :     Tuple       	=   [
			    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
			lowerCAmelCase__  :     int       	=   model.generate(_SCREAMING_SNAKE_CASE						,   do_sample=_SCREAMING_SNAKE_CASE						)
			self.assertListEqual(output_ids[0].numpy().tolist()						,   _SCREAMING_SNAKE_CASE						)








import math






def 	lowerCamelCase_       (			_a			):




		"""simple docstring"""






		if 1 < number < 4:
				# 2 and 3 are primes
				return True
		elif number < 2 or number % 2 == 0 or number % 3 == 0:
				# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
				return False

		# All primes number are in format of 6k +/- 1
		for i in range(5      ,  int(math.sqrt(_a			) + 1			)      ,  6			):
				if number % i == 0 or number % (i + 2) == 0:
						return False
		return True






def 	lowerCamelCase_       (			_a = 1_000      ,  _a = 1_000			):




		"""simple docstring"""






		lowerCAmelCase__  :     Union[str, Any]       	=   [0, 0, 0]  # length, a, b
		for a in range((a_limit * -1) + 1      ,  _a			):
				for b in range(2      ,  _a			):
						if is_prime(_a			):
								lowerCAmelCase__  :     str       	=   0
								lowerCAmelCase__  :     int       	=   0
								while is_prime((n**2) + (a * n) + b			):
										count += 1
										n += 1
								if count > longest[0]:
										lowerCAmelCase__  :     Dict       	=   [count, a, b]
		lowerCAmelCase__  :     int       	=   longest[1] * longest[2]
		return ans


if __name__ == "__main__":
		print(solution(1000, 1000))




