





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    :

       def __init__(						self:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       Union[str, Any]    ,      )				->       List[str]:




              """simple docstring"""


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

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




              """simple docstring"""


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

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

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

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

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




              """simple docstring"""


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

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

       def lowercase       (						self:       List[str]    ,      _SCREAMING_SNAKE_CASE:       str    ,      _SCREAMING_SNAKE_CASE:       int    ,      _SCREAMING_SNAKE_CASE:       Tuple    ,      _SCREAMING_SNAKE_CASE:       str    ,      _SCREAMING_SNAKE_CASE:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       List[Any]    ,      _SCREAMING_SNAKE_CASE:       Tuple    ,      _SCREAMING_SNAKE_CASE:       Any    ,      _SCREAMING_SNAKE_CASE:       List[str]    ,      )				->       str:




              """simple docstring"""


              UpperCamelCase_      				=     TFXLMWithLMHeadModel(_SCREAMING_SNAKE_CASE						)

              UpperCamelCase_      				=     {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
              UpperCamelCase_      				=     model(_SCREAMING_SNAKE_CASE						)

              UpperCamelCase_      				=     outputs

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

       def lowercase       (						self:       Dict    ,      _SCREAMING_SNAKE_CASE:       List[str]    ,      _SCREAMING_SNAKE_CASE:       Tuple    ,      _SCREAMING_SNAKE_CASE:       Tuple    ,      _SCREAMING_SNAKE_CASE:       Any    ,      _SCREAMING_SNAKE_CASE:       Union[str, Any]    ,      _SCREAMING_SNAKE_CASE:       Optional[Any]    ,      _SCREAMING_SNAKE_CASE:       str    ,      _SCREAMING_SNAKE_CASE:       Tuple    ,      _SCREAMING_SNAKE_CASE:       Optional[Any]    ,      )				->       Optional[int]:




              """simple docstring"""


              UpperCamelCase_      				=     TFXLMForQuestionAnsweringSimple(_SCREAMING_SNAKE_CASE						)

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

              UpperCamelCase_      				=     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 lowercase       (						self:       List[Any]    ,      _SCREAMING_SNAKE_CASE:       List[Any]    ,      _SCREAMING_SNAKE_CASE:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       Dict    ,      _SCREAMING_SNAKE_CASE:       Dict    ,      _SCREAMING_SNAKE_CASE:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       Optional[Any]    ,      _SCREAMING_SNAKE_CASE:       Any    ,      _SCREAMING_SNAKE_CASE:       str    ,      )				->       Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_      				=     TFXLMForSequenceClassification(_SCREAMING_SNAKE_CASE						)

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

              UpperCamelCase_      				=     model(_SCREAMING_SNAKE_CASE						)

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

       def lowercase       (						self:       str    ,      _SCREAMING_SNAKE_CASE:       Union[str, Any]    ,      _SCREAMING_SNAKE_CASE:       Dict    ,      _SCREAMING_SNAKE_CASE:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       Any    ,      _SCREAMING_SNAKE_CASE:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       Optional[Any]    ,      _SCREAMING_SNAKE_CASE:       Any    ,      _SCREAMING_SNAKE_CASE:       Union[str, Any]    ,      _SCREAMING_SNAKE_CASE:       Dict    ,      )				->       str:




              """simple docstring"""


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

       def lowercase       (						self:       Tuple    ,      _SCREAMING_SNAKE_CASE:       List[str]    ,      _SCREAMING_SNAKE_CASE:       Optional[Any]    ,      _SCREAMING_SNAKE_CASE:       int    ,      _SCREAMING_SNAKE_CASE:       List[Any]    ,      _SCREAMING_SNAKE_CASE:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       Dict    ,      _SCREAMING_SNAKE_CASE:       Tuple    ,      _SCREAMING_SNAKE_CASE:       str    ,      _SCREAMING_SNAKE_CASE:       List[str]    ,      )				->       Optional[Any]:




              """simple docstring"""


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



       def lowercase       (						self:       Union[str, Any]						)				->       Dict:




              """simple docstring"""


              UpperCamelCase_      				=     self.prepare_config_and_inputs()
              (
                  (
                  UpperCamelCase_
              )				,       (
                  UpperCamelCase_
              )				,       (
                  UpperCamelCase_
              )				,       (
                  UpperCamelCase_
              )				,       (
                  UpperCamelCase_
              )				,       (
                  UpperCamelCase_
              )				,       (
                  UpperCamelCase_
              )				,       (
                  UpperCamelCase_
              )				,       (
                  UpperCamelCase_
              )				,       
              )      				=     config_and_inputs
              UpperCamelCase_      				=     {
                  "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    (		lowerCAmelCase_     ,  lowerCAmelCase_     ,  unittest.TestCase   ):
       _UpperCamelCase :    Dict   			=      (
           (
               TFXLMModel,
               TFXLMWithLMHeadModel,
               TFXLMForSequenceClassification,
               TFXLMForQuestionAnsweringSimple,
               TFXLMForTokenClassification,
               TFXLMForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       _UpperCamelCase :    Optional[Any]   			=      (
           (TFXLMWithLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       _UpperCamelCase :    int   			=      (
           {
               '''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 :    Optional[Any]   			=      False
       _UpperCamelCase :    Tuple   			=      False

       def lowercase       (						self:       str    ,      _SCREAMING_SNAKE_CASE:       Dict    ,      _SCREAMING_SNAKE_CASE:       List[str]    ,      _SCREAMING_SNAKE_CASE:       Union[str, Any]    ,      _SCREAMING_SNAKE_CASE:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       List[Any]						)				->       List[Any]:




              """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 lowercase       (						self:       Union[str, Any]						)				->       List[Any]:




              """simple docstring"""


              UpperCamelCase_      				=     TFXLMModelTester(self						)
              UpperCamelCase_      				=     ConfigTester(self    ,      config_class=_SCREAMING_SNAKE_CASE    ,      emb_dim=37						)

       def lowercase       (						self:       Dict						)				->       Any:




              """simple docstring"""


              self.config_tester.run_common_tests()

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




              """simple docstring"""


              UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_model(*_SCREAMING_SNAKE_CASE						)

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




              """simple docstring"""


              UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_lm_head(*_SCREAMING_SNAKE_CASE						)

       def lowercase       (						self:       Union[str, Any]						)				->       int:




              """simple docstring"""


              UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_qa(*_SCREAMING_SNAKE_CASE						)

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




              """simple docstring"""


              UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_sequence_classif(*_SCREAMING_SNAKE_CASE						)

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




              """simple docstring"""


              UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_for_token_classification(*_SCREAMING_SNAKE_CASE						)

       def lowercase       (						self:       int						)				->       Dict:




              """simple docstring"""


              UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_for_multiple_choice(*_SCREAMING_SNAKE_CASE						)



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




              """simple docstring"""


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



@require_tf
class 							_UpperCamelCase    (		unittest.TestCase   ):

       @slow
       def lowercase       (						self:       Union[str, Any]						)				->       Any:




              """simple docstring"""


              UpperCamelCase_      				=     TFXLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"						)
              UpperCamelCase_      				=     tf.convert_to_tensor([[14, 447]]    ,      dtype=tf.intaa						)  # the president
              UpperCamelCase_      				=     [
                  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
              UpperCamelCase_      				=     model.generate(_SCREAMING_SNAKE_CASE    ,      do_sample=_SCREAMING_SNAKE_CASE						)
              self.assertListEqual(output_ids[0].numpy().tolist()    ,      _SCREAMING_SNAKE_CASE						)








import math




def        lowerCAmelCase_       (							UpperCamelCase_     )   ->						bool:

       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(UpperCamelCase_     ) + 1     )    ,						6     ):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True




def        lowerCAmelCase_       (							UpperCamelCase_ = 600851475143     )   ->						int:

       try:
              UpperCamelCase_      				=     int(UpperCamelCase_     )
       except (TypeError, ValueError):
              raise TypeError("Parameter n must be int or castable to int."     )
       if n <= 0:
              raise ValueError("Parameter n must be greater than or equal to one."     )
       UpperCamelCase_      				=     0
       if is_prime(UpperCamelCase_     ):
              return n
       while n % 2 == 0:
              n //= 2
       if is_prime(UpperCamelCase_     ):
              return n
       for i in range(3    ,						int(math.sqrt(UpperCamelCase_     )     ) + 1    ,						2     ):
              if n % i == 0:
                     if is_prime(n // i     ):
                            UpperCamelCase_      				=     n // i
                            break
                     elif is_prime(UpperCamelCase_     ):
                            UpperCamelCase_      				=     i
       return max_number


if __name__ == "__main__":
     print(f'''{solution() = }''')

