



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				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	List[str]	,						):


           '''simple docstring'''

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



       def 						_lowerCamelCase     (						self				:	Any):


           '''simple docstring'''

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

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

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

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

           __a					=							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				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	int	,						__SCREAMING_SNAKE_CASE				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	Any	,						__SCREAMING_SNAKE_CASE				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]	,						__SCREAMING_SNAKE_CASE				:	int	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	List[Any]	,						):


           '''simple docstring'''

           __a					=							TFXLMModel(config=__SCREAMING_SNAKE_CASE)
           __a					=							{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
           __a					=							model(__SCREAMING_SNAKE_CASE)

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



       def 						_lowerCamelCase     (						self				:	int	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	Any	,						__SCREAMING_SNAKE_CASE				:	Dict	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]	,						__SCREAMING_SNAKE_CASE				:	Any	,						__SCREAMING_SNAKE_CASE				:	int	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]	,						):


           '''simple docstring'''

           __a					=							TFXLMWithLMHeadModel(__SCREAMING_SNAKE_CASE)

           __a					=							{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
           __a					=							model(__SCREAMING_SNAKE_CASE)

           __a					=							outputs

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



       def 						_lowerCamelCase     (						self				:	Any	,						__SCREAMING_SNAKE_CASE				:	List[Any]	,						__SCREAMING_SNAKE_CASE				:	int	,						__SCREAMING_SNAKE_CASE				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	Dict	,						__SCREAMING_SNAKE_CASE				:	Dict	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	str	,						):


           '''simple docstring'''

           __a					=							TFXLMForQuestionAnsweringSimple(__SCREAMING_SNAKE_CASE)

           __a					=							{'''input_ids''': input_ids, '''lengths''': input_lengths}

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


           '''simple docstring'''

           __a					=							TFXLMForSequenceClassification(__SCREAMING_SNAKE_CASE)

           __a					=							{'''input_ids''': input_ids, '''lengths''': input_lengths}

           __a					=							model(__SCREAMING_SNAKE_CASE)

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



       def 						_lowerCamelCase     (						self				:	Optional[int]	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]	,						__SCREAMING_SNAKE_CASE				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	Optional[int]	,						__SCREAMING_SNAKE_CASE				:	Dict	,						__SCREAMING_SNAKE_CASE				:	int	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	Any	,						):


           '''simple docstring'''

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



       def 						_lowerCamelCase     (						self				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	Dict	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]	,						__SCREAMING_SNAKE_CASE				:	Dict	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	Any	,						):


           '''simple docstring'''

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





       def 						_lowerCamelCase     (						self				:	Tuple):


           '''simple docstring'''

           __a					=							self.prepare_config_and_inputs()
           (
               (
               __a
           )			,  (
               __a
           )			,  (
               __a
           )			,  (
               __a
           )			,  (
               __a
           )			,  (
               __a
           )			,  (
               __a
           )			,  (
               __a
           )			,  (
               __a
           )			,  
           )					=							config_and_inputs
           __a					=							{
               '''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			(      __UpperCAmelCase ,__UpperCAmelCase ,unittest.TestCase       ):
       UpperCamelCase__    :       List[str]		   =		(
           (
               TFXLMModel,
               TFXLMWithLMHeadModel,
               TFXLMForSequenceClassification,
               TFXLMForQuestionAnsweringSimple,
               TFXLMForTokenClassification,
               TFXLMForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       UpperCamelCase__    :       Any		   =		(
           (TFXLMWithLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       UpperCamelCase__    :       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 {}
       )
       UpperCamelCase__    :       str		   =		False
       UpperCamelCase__    :       List[Any]		   =		False



       def 						_lowerCamelCase     (						self				:	List[Any]	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	List[Any]	,						__SCREAMING_SNAKE_CASE				:	Optional[int]	,						__SCREAMING_SNAKE_CASE				:	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 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

           __a					=							TFXLMModelTester(self)
           __a					=							ConfigTester(self	,						config_class=__SCREAMING_SNAKE_CASE	,						emb_dim=37)



       def 						_lowerCamelCase     (						self				:	str):


           '''simple docstring'''

           self.config_tester.run_common_tests()



       def 						_lowerCamelCase     (						self				:	List[str]):


           '''simple docstring'''

           __a					=							self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_model(*__SCREAMING_SNAKE_CASE)



       def 						_lowerCamelCase     (						self				:	Optional[Any]):


           '''simple docstring'''

           __a					=							self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_lm_head(*__SCREAMING_SNAKE_CASE)



       def 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

           __a					=							self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_qa(*__SCREAMING_SNAKE_CASE)



       def 						_lowerCamelCase     (						self				:	List[Any]):


           '''simple docstring'''

           __a					=							self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_sequence_classif(*__SCREAMING_SNAKE_CASE)



       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

           __a					=							self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_for_token_classification(*__SCREAMING_SNAKE_CASE)



       def 						_lowerCamelCase     (						self				:	List[str]):


           '''simple docstring'''

           __a					=							self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_for_multiple_choice(*__SCREAMING_SNAKE_CASE)





       @slow
       def 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

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


@require_tf
class        _A			(      unittest.TestCase       ):



       @slow
       def 						_lowerCamelCase     (						self				:	Optional[Any]):


           '''simple docstring'''

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










def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase  ,					_UpperCAmelCase							):
    __a					=							[1 / first_term]
    __a					=							1 / first_term
    for _ in range(number_of_terms - 1							):
        first_term += common_difference
        arithmetic_progression.append(_UpperCAmelCase							)
    __a					=							[1 / step for step in arithmetic_progression]
    return sum(_UpperCAmelCase							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(sum_of_harmonic_progression(1 / 2, 2, 2))





