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






    '''simple docstring'''




    def __init__(						self					,	lowerCamelCase__					,	):
       lowerCAmelCase_:       List[str]         =  parent
       lowerCAmelCase_:       List[Any]         =  13
       lowerCAmelCase_:       Any         =  7
       lowerCAmelCase_:       Tuple         =  True
       lowerCAmelCase_:       Any         =  True
       lowerCAmelCase_:       Union[str, Any]         =  True
       lowerCAmelCase_:       Tuple         =  True
       lowerCAmelCase_:       Optional[int]         =  True
       lowerCAmelCase_:       Tuple         =  False
       lowerCAmelCase_:       Union[str, Any]         =  False
       lowerCAmelCase_:       List[Any]         =  False
       lowerCAmelCase_:       Union[str, Any]         =  2
       lowerCAmelCase_:       Any         =  99
       lowerCAmelCase_:       str         =  0
       lowerCAmelCase_:       Optional[Any]         =  32
       lowerCAmelCase_:       Optional[Any]         =  2
       lowerCAmelCase_:       int         =  4
       lowerCAmelCase_:       Union[str, Any]         =  0.1
       lowerCAmelCase_:       List[Any]         =  0.1
       lowerCAmelCase_:       List[Any]         =  512
       lowerCAmelCase_:       Tuple         =  16
       lowerCAmelCase_:       Tuple         =  2
       lowerCAmelCase_:       List[Any]         =  0.0_2
       lowerCAmelCase_:       Optional[int]         =  3
       lowerCAmelCase_:       Optional[int]         =  4
       lowerCAmelCase_:       List[Any]         =  """last"""
       lowerCAmelCase_:       List[str]         =  True
       lowerCAmelCase_:       Any         =  None
       lowerCAmelCase_:       Any         =  0




    def     _a						(						self   ):
       lowerCAmelCase_:       int         =  ids_tensor([self.batch_size, self.seq_length]					,	self.vocab_size   )
       lowerCAmelCase_:       Tuple         =  random_attention_mask([self.batch_size, self.seq_length]					,	dtype=tf.floataa   )

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

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

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

       lowerCAmelCase_:       Tuple         =  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     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
       lowerCAmelCase_:       Union[str, Any]         =  TFXLMModel(config=_lowerCAmelCase   )
       lowerCAmelCase_:       Optional[Any]         =  {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
       lowerCAmelCase_:       List[Any]         =  model(_lowerCAmelCase   )

       lowerCAmelCase_:       str         =  [input_ids, input_mask]
       lowerCAmelCase_:       str         =  model(_lowerCAmelCase   )
       self.parent.assertEqual(result.last_hidden_state.shape					,	(self.batch_size, self.seq_length, self.hidden_size)   )




    def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
       lowerCAmelCase_:       Optional[Any]         =  TFXLMWithLMHeadModel(_lowerCAmelCase   )

       lowerCAmelCase_:       int         =  {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
       lowerCAmelCase_:       List[str]         =  model(_lowerCAmelCase   )

       lowerCAmelCase_:       str         =  outputs

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




    def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
       lowerCAmelCase_:       Tuple         =  TFXLMForQuestionAnsweringSimple(_lowerCAmelCase   )

       lowerCAmelCase_:       Dict         =  {"""input_ids""": input_ids, """lengths""": input_lengths}

       lowerCAmelCase_:       Union[str, Any]         =  model(_lowerCAmelCase   )

       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     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
       lowerCAmelCase_:       List[Any]         =  TFXLMForSequenceClassification(_lowerCAmelCase   )

       lowerCAmelCase_:       Tuple         =  {"""input_ids""": input_ids, """lengths""": input_lengths}

       lowerCAmelCase_:       Tuple         =  model(_lowerCAmelCase   )

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




    def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
       lowerCAmelCase_:       Union[str, Any]         =  self.num_labels
       lowerCAmelCase_:       Optional[Any]         =  TFXLMForTokenClassification(config=_lowerCAmelCase   )
       lowerCAmelCase_:       str         =  {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
       lowerCAmelCase_:       Union[str, Any]         =  model(_lowerCAmelCase   )
       self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.seq_length, self.num_labels)   )




    def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
       lowerCAmelCase_:       List[Any]         =  self.num_choices
       lowerCAmelCase_:       Optional[int]         =  TFXLMForMultipleChoice(config=_lowerCAmelCase   )
       lowerCAmelCase_:       Tuple         =  tf.tile(tf.expand_dims(_lowerCAmelCase					,	1   )					,	(1, self.num_choices, 1)   )
       lowerCAmelCase_:       List[Any]         =  tf.tile(tf.expand_dims(_lowerCAmelCase					,	1   )					,	(1, self.num_choices, 1)   )
       lowerCAmelCase_:       Optional[Any]         =  tf.tile(tf.expand_dims(_lowerCAmelCase					,	1   )					,	(1, self.num_choices, 1)   )
       lowerCAmelCase_:       Union[str, Any]         =  {
           """input_ids""": multiple_choice_inputs_ids,
           """attention_mask""": multiple_choice_input_mask,
           """token_type_ids""": multiple_choice_token_type_ids,
       }
       lowerCAmelCase_:       Optional[Any]         =  model(_lowerCAmelCase   )
       self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.num_choices)   )




    def     _a						(						self   ):
       lowerCAmelCase_:       int         =  self.prepare_config_and_inputs()
       (
           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 				_lowercase						(    __lowerCamelCase   ,     __lowerCamelCase   ,     unittest.TestCase ):






    '''simple docstring'''
    SCREAMING_SNAKE_CASE:							List[Any]        =						(
        (
            TFXLMModel,
            TFXLMWithLMHeadModel,
            TFXLMForSequenceClassification,
            TFXLMForQuestionAnsweringSimple,
            TFXLMForTokenClassification,
            TFXLMForMultipleChoice,
        )
        if is_tf_available()
        else ()
    )
    SCREAMING_SNAKE_CASE:							Optional[int]        =						(
        (TFXLMWithLMHeadModel,) if is_tf_available() else ()
    )  # TODO (PVP): Check other models whether language generation is also applicable
    SCREAMING_SNAKE_CASE:							List[Any]        =						(
        {
            '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 {}
    )
    SCREAMING_SNAKE_CASE:							List[Any]        =						False
    SCREAMING_SNAKE_CASE:							int        =						False




    def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__   ):
       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     _a						(						self   ):
       lowerCAmelCase_:       List[Any]         =  TFXLMModelTester(self   )
       lowerCAmelCase_:       Optional[Any]         =  ConfigTester(self					,	config_class=_lowerCAmelCase					,	emb_dim=37   )




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




    def     _a						(						self   ):
       lowerCAmelCase_:       Tuple         =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_model(*_lowerCAmelCase   )




    def     _a						(						self   ):
       lowerCAmelCase_:       str         =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_lm_head(*_lowerCAmelCase   )




    def     _a						(						self   ):
       lowerCAmelCase_:       Optional[Any]         =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_qa(*_lowerCAmelCase   )




    def     _a						(						self   ):
       lowerCAmelCase_:       Tuple         =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_sequence_classif(*_lowerCAmelCase   )




    def     _a						(						self   ):
       lowerCAmelCase_:       int         =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_for_token_classification(*_lowerCAmelCase   )




    def     _a						(						self   ):
       lowerCAmelCase_:       Dict         =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_for_multiple_choice(*_lowerCAmelCase   )




    @slow
    def     _a						(						self   ):
       for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowerCAmelCase_:       int         =  TFXLMModel.from_pretrained(_lowerCAmelCase   )
          self.assertIsNotNone(_lowerCAmelCase   )





@require_tf
class 				_lowercase						(    unittest.TestCase ):






    '''simple docstring'''




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




import itertools
def 		snake_case__  (		lowercase				):
   return (
       int("".join(combination[0:2]				)				) * int("".join(combination[2:5]				)				)
       == int("".join(combination[5:9]				)				)
   ) or (
       int("".join(combination[0]				)				) * int("".join(combination[1:5]				)				)
       == int("".join(combination[5:9]				)				)
   )
def 		snake_case__  (		):
   return sum(
       {
           int("".join(pandigital[5:9]				)				)
           for pandigital in itertools.permutations("123456789"				)
           if is_combination_valid(lowercase				)
       }				)


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