




import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     XLMForMultipleChoice,
     XLMForQuestionAnswering,
     XLMForQuestionAnsweringSimple,
     XLMForSequenceClassification,
     XLMForTokenClassification,
     XLMModel,
     XLMWithLMHeadModel,
 )
 from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST







class     A:



 '''simple docstring'''


 def __init__(							self   :    Dict		,				A_   :    str		,				A_   :    Any=13		,				A_   :    Any=7		,				A_   :    List[Any]=True		,				A_   :    List[Any]=True		,				A_   :    List[str]=True		,				A_   :    Any=True		,				A_   :    Union[str, Any]=True		,				A_   :    List[str]=False		,				A_   :    Any=False		,				A_   :    List[Any]=False		,				A_   :    Optional[int]=2		,				A_   :    Any=99		,				A_   :    List[Any]=0		,				A_   :    List[Any]=32		,				A_   :    List[Any]=5		,				A_   :    Optional[int]=4		,				A_   :    List[Any]=0.1		,				A_   :    Optional[int]=0.1		,				A_   :    Tuple=512		,				A_   :    Union[str, Any]=2		,				A_   :    List[Any]=0.02		,				A_   :    int=2		,				A_   :    str=4		,				A_   :    Optional[Any]="last"		,				A_   :    Tuple=True		,				A_   :    Any=None		,				A_   :    List[Any]=0		,				)  ->      List[Any]:

       """simple docstring"""






       lowerCamelCase_							=       parent
       lowerCamelCase_							=       batch_size
       lowerCamelCase_							=       seq_length
       lowerCamelCase_							=       is_training
       lowerCamelCase_							=       use_input_lengths
       lowerCamelCase_							=       use_token_type_ids
       lowerCamelCase_							=       use_labels
       lowerCamelCase_							=       gelu_activation
       lowerCamelCase_							=       sinusoidal_embeddings
       lowerCamelCase_							=       causal
       lowerCamelCase_							=       asm
       lowerCamelCase_							=       n_langs
       lowerCamelCase_							=       vocab_size
       lowerCamelCase_							=       n_special
       lowerCamelCase_							=       hidden_size
       lowerCamelCase_							=       num_hidden_layers
       lowerCamelCase_							=       num_attention_heads
       lowerCamelCase_							=       hidden_dropout_prob
       lowerCamelCase_							=       attention_probs_dropout_prob
       lowerCamelCase_							=       max_position_embeddings
       lowerCamelCase_							=       type_sequence_label_size
       lowerCamelCase_							=       initializer_range
       lowerCamelCase_							=       num_labels
       lowerCamelCase_							=       num_choices
       lowerCamelCase_							=       summary_type
       lowerCamelCase_							=       use_proj
       lowerCamelCase_							=       scope
       lowerCamelCase_							=       bos_token_id

 def 							a__					(							self   :    int    )  ->      Optional[Any]:

       """simple docstring"""






       lowerCamelCase_							=       ids_tensor([self.batch_size, self.seq_length]		,				self.vocab_size    )
       lowerCamelCase_							=       random_attention_mask([self.batch_size, self.seq_length]    )

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

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

       lowerCamelCase_							=       None
       lowerCamelCase_							=       None
       lowerCamelCase_							=       None
       if self.use_labels:
             lowerCamelCase_							=       ids_tensor([self.batch_size]		,				self.type_sequence_label_size    )
             lowerCamelCase_							=       ids_tensor([self.batch_size, self.seq_length]		,				self.num_labels    )
             lowerCamelCase_							=       ids_tensor([self.batch_size]		,				2    ).float()
             lowerCamelCase_							=       ids_tensor([self.batch_size]		,				self.num_choices    )

       lowerCamelCase_							=       self.get_config()

       return (
           config,
           input_ids,
           token_type_ids,
           input_lengths,
           sequence_labels,
           token_labels,
           is_impossible_labels,
           choice_labels,
           input_mask,
       )

 def 							a__					(							self   :    Tuple    )  ->      Optional[Any]:

       """simple docstring"""






       return 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		,				num_labels=self.num_labels		,				bos_token_id=self.bos_token_id		,				)

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

       """simple docstring"""






       lowerCamelCase_							=       XLMModel(config=A_    )
       model.to(A_    )
       model.eval()
       lowerCamelCase_							=       model(A_		,				lengths=A_		,				langs=A_    )
       lowerCamelCase_							=       model(A_		,				langs=A_    )
       lowerCamelCase_							=       model(A_    )
       self.parent.assertEqual(result.last_hidden_state.shape		,				(self.batch_size, self.seq_length, self.hidden_size)    )

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

       """simple docstring"""






       lowerCamelCase_							=       XLMWithLMHeadModel(A_    )
       model.to(A_    )
       model.eval()

       lowerCamelCase_							=       model(A_		,				token_type_ids=A_		,				labels=A_    )
       self.parent.assertEqual(result.loss.shape		,				()    )
       self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.seq_length, self.vocab_size)    )

 def 							a__					(							self   :    List[str]		,				A_   :    Tuple		,				A_   :    str		,				A_   :    List[Any]		,				A_   :    List[str]		,				A_   :    Any		,				A_   :    List[Any]		,				A_   :    List[str]		,				A_   :    Any		,				A_   :    List[Any]		,				)  ->      List[Any]:

       """simple docstring"""






       lowerCamelCase_							=       XLMForQuestionAnsweringSimple(A_    )
       model.to(A_    )
       model.eval()

       lowerCamelCase_							=       model(A_    )

       lowerCamelCase_							=       model(A_		,				start_positions=A_		,				end_positions=A_    )
       lowerCamelCase_							=       outputs
       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   :    List[str]		,				A_   :    Union[str, Any]		,				A_   :    Tuple		,				A_   :    int		,				A_   :    Any		,				A_   :    int		,				A_   :    str		,				A_   :    Union[str, Any]		,				A_   :    Union[str, Any]		,				A_   :    Union[str, Any]		,				)  ->      Optional[int]:

       """simple docstring"""






       lowerCamelCase_							=       XLMForQuestionAnswering(A_    )
       model.to(A_    )
       model.eval()

       lowerCamelCase_							=       model(A_    )

       lowerCamelCase_							=       model(
           A_		,				start_positions=A_		,				end_positions=A_		,				cls_index=A_		,				is_impossible=A_		,				p_mask=A_		,				)

       lowerCamelCase_							=       model(
           A_		,				start_positions=A_		,				end_positions=A_		,				cls_index=A_		,				is_impossible=A_		,				)

       ((lowerCamelCase_)	,							)							=       result_with_labels.to_tuple()

       lowerCamelCase_							=       model(A_		,				start_positions=A_		,				end_positions=A_    )

       ((lowerCamelCase_)	,							)							=       result_with_labels.to_tuple()

       self.parent.assertEqual(result_with_labels.loss.shape		,				()    )
       self.parent.assertEqual(result.start_top_log_probs.shape		,				(self.batch_size, model.config.start_n_top)    )
       self.parent.assertEqual(result.start_top_index.shape		,				(self.batch_size, model.config.start_n_top)    )
       self.parent.assertEqual(
           result.end_top_log_probs.shape		,				(self.batch_size, model.config.start_n_top * model.config.end_n_top)    )
       self.parent.assertEqual(
           result.end_top_index.shape		,				(self.batch_size, model.config.start_n_top * model.config.end_n_top)    )
       self.parent.assertEqual(result.cls_logits.shape		,				(self.batch_size,)    )

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

       """simple docstring"""






       lowerCamelCase_							=       XLMForSequenceClassification(A_    )
       model.to(A_    )
       model.eval()

       lowerCamelCase_							=       model(A_    )
       lowerCamelCase_							=       model(A_		,				labels=A_    )
       self.parent.assertEqual(result.loss.shape		,				()    )
       self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.type_sequence_label_size)    )

 def 							a__					(							self   :    Optional[Any]		,				A_   :    str		,				A_   :    List[str]		,				A_   :    str		,				A_   :    str		,				A_   :    Any		,				A_   :    Union[str, Any]		,				A_   :    Tuple		,				A_   :    Optional[Any]		,				A_   :    Optional[int]		,				)  ->      int:

       """simple docstring"""






       lowerCamelCase_							=       self.num_labels
       lowerCamelCase_							=       XLMForTokenClassification(A_    )
       model.to(A_    )
       model.eval()

       lowerCamelCase_							=       model(A_		,				attention_mask=A_		,				labels=A_    )
       self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.seq_length, self.num_labels)    )

 def 							a__					(							self   :    Union[str, Any]		,				A_   :    int		,				A_   :    Union[str, Any]		,				A_   :    int		,				A_   :    List[Any]		,				A_   :    List[str]		,				A_   :    List[str]		,				A_   :    List[Any]		,				A_   :    str		,				A_   :    str		,				)  ->      Tuple:

       """simple docstring"""






       lowerCamelCase_							=       self.num_choices
       lowerCamelCase_							=       XLMForMultipleChoice(config=A_    )
       model.to(A_    )
       model.eval()
       lowerCamelCase_							=       input_ids.unsqueeze(1    ).expand(-1		,				self.num_choices		,				-1    ).contiguous()
       lowerCamelCase_							=       token_type_ids.unsqueeze(1    ).expand(-1		,				self.num_choices		,				-1    ).contiguous()
       lowerCamelCase_							=       input_mask.unsqueeze(1    ).expand(-1		,				self.num_choices		,				-1    ).contiguous()
       lowerCamelCase_							=       model(
           A_		,				attention_mask=A_		,				token_type_ids=A_		,				labels=A_		,				)
       self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_choices)    )





 def 							a__					(							self   :    int    )  ->      int:

       """simple docstring"""






       lowerCamelCase_							=       self.prepare_config_and_inputs()
       (
           (
           lowerCamelCase_
       )	,							(
           lowerCamelCase_
       )	,							(
           lowerCamelCase_
       )	,							(
           lowerCamelCase_
       )	,							(
           lowerCamelCase_
       )	,							(
           lowerCamelCase_
       )	,							(
           lowerCamelCase_
       )	,							(
           lowerCamelCase_
       )	,							(
           lowerCamelCase_
       )	,							
       )							=       config_and_inputs
       lowerCamelCase_							=       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'lengths': input_lengths}
       return config, inputs_dict







@require_torch
class     A(		UpperCamelCase				, UpperCamelCase				, UpperCamelCase				, unittest.TestCase  ):



 '''simple docstring'''


 UpperCamelCase		  =		(
     (
         XLMModel,
         XLMWithLMHeadModel,
         XLMForQuestionAnswering,
         XLMForSequenceClassification,
         XLMForQuestionAnsweringSimple,
         XLMForTokenClassification,
         XLMForMultipleChoice,
     )
     if is_torch_available()
     else ()
 )
 UpperCamelCase		  =		(
     (XLMWithLMHeadModel,) if is_torch_available() else ()
 )  # TODO (PVP): Check other models whether language generation is also applicable
 UpperCamelCase		  =		(
     {
         '''feature-extraction''': XLMModel,
         '''fill-mask''': XLMWithLMHeadModel,
         '''question-answering''': XLMForQuestionAnsweringSimple,
         '''text-classification''': XLMForSequenceClassification,
         '''text-generation''': XLMWithLMHeadModel,
         '''token-classification''': XLMForTokenClassification,
         '''zero-shot''': XLMForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )

 def 							a__					(							self   :    Optional[Any]		,				A_   :    Optional[Any]		,				A_   :    Optional[Any]		,				A_   :    List[Any]		,				A_   :    Dict		,				A_   :    List[str]    )  ->      Dict:

       """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 							a__					(							self   :    List[str]		,				A_   :    List[Any]		,				A_   :    List[str]		,				A_   :    Tuple=False    )  ->      Optional[Any]:

       """simple docstring"""






       lowerCamelCase_							=       super()._prepare_for_class(A_		,				A_		,				return_labels=A_    )

       if return_labels:
             if model_class.__name__ == "XLMForQuestionAnswering":
                   lowerCamelCase_							=       torch.zeros(
                       self.model_tester.batch_size		,				dtype=torch.long		,				device=A_    )
                   lowerCamelCase_							=       torch.zeros(
                       self.model_tester.batch_size		,				dtype=torch.long		,				device=A_    )

       return inputs_dict

 def 							a__					(							self   :    Tuple    )  ->      List[Any]:

       """simple docstring"""






       lowerCamelCase_							=       XLMModelTester(self    )
       lowerCamelCase_							=       ConfigTester(self		,				config_class=A_		,				emb_dim=37    )

 def 							a__					(							self   :    int    )  ->      Optional[Any]:

       """simple docstring"""






       self.config_tester.run_common_tests()

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

       """simple docstring"""






       lowerCamelCase_							=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_model(*A_    )

 def 							a__					(							self   :    Optional[Any]    )  ->      int:

       """simple docstring"""






       lowerCamelCase_							=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_lm_head(*A_    )

 def 							a__					(							self   :    Tuple    )  ->      Optional[int]:

       """simple docstring"""






       lowerCamelCase_							=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_simple_qa(*A_    )

 def 							a__					(							self   :    List[Any]    )  ->      Any:

       """simple docstring"""






       lowerCamelCase_							=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_qa(*A_    )

 def 							a__					(							self   :    str    )  ->      Tuple:

       """simple docstring"""






       lowerCamelCase_							=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_sequence_classif(*A_    )

 def 							a__					(							self   :    Optional[Any]    )  ->      Optional[int]:

       """simple docstring"""






       lowerCamelCase_							=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_token_classif(*A_    )

 def 							a__					(							self   :    int    )  ->      Dict:

       """simple docstring"""






       lowerCamelCase_							=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_for_multiple_choice(*A_    )

 def 							a__					(							self   :    List[str]		,				A_   :    Tuple		,				A_   :    List[str]		,				A_   :    Optional[int]		,				A_   :    Optional[Any]		,				A_   :    str		,				A_   :    Tuple=False		,				A_   :    Optional[int]=1    )  ->      Optional[Any]:

       """simple docstring"""






       self.assertIsInstance(A_		,				A_    )
       self.assertListEqual(
           [isinstance(A_		,				A_    ) for iter_attentions in attentions]		,				[True] * len(A_    )    )
       self.assertEqual(len(A_    )		,				(max_length - min_length) * num_beam_groups    )

       for idx, iter_attentions in enumerate(A_    ):
             # adds PAD dummy token
             lowerCamelCase_							=       min_length + idx + 1
             lowerCamelCase_							=       min_length + idx + 1

             lowerCamelCase_							=       (
                 batch_size * num_beam_groups,
                 config.num_attention_heads,
                 tgt_len,
                 src_len,
             )
             # check attn size
             self.assertListEqual(
                 [layer_attention.shape for layer_attention in iter_attentions]		,				[expected_shape] * len(A_    )    )

 def 							a__					(							self   :    Union[str, Any]		,				A_   :    Tuple		,				A_   :    List[str]		,				A_   :    str		,				A_   :    Any		,				A_   :    str		,				A_   :    Any=False		,				A_   :    List[str]=1    )  ->      int:

       """simple docstring"""






       self.assertIsInstance(A_		,				A_    )
       self.assertListEqual(
           [isinstance(A_		,				A_    ) for iter_hidden_states in hidden_states]		,				[True] * len(A_    )		,				)
       self.assertEqual(len(A_    )		,				(max_length - min_length) * num_beam_groups    )

       for idx, iter_hidden_states in enumerate(A_    ):
             # adds PAD dummy token
             lowerCamelCase_							=       min_length + idx + 1
             lowerCamelCase_							=       (batch_size * num_beam_groups, seq_len, config.hidden_size)
             # check hidden size
             self.assertListEqual(
                 [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]		,				[expected_shape] * len(A_    )		,				)
       pass





 @slow
 def 							a__					(							self   :    Tuple    )  ->      Any:

       """simple docstring"""






       for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase_							=       XLMModel.from_pretrained(A_    )
             self.assertIsNotNone(A_    )







@require_torch
class     A(		unittest.TestCase  ):



 '''simple docstring'''


 @slow
 def 							a__					(							self   :    str    )  ->      str:

       """simple docstring"""






       lowerCamelCase_							=       XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'    )
       model.to(A_    )
       lowerCamelCase_							=       torch.tensor([[14, 447]]		,				dtype=torch.long		,				device=A_    )  # the president
       lowerCamelCase_							=       [
           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_							=       model.generate(A_		,				do_sample=A_    )
       self.assertListEqual(output_ids[0].cpu().numpy().tolist()		,				A_    )









def    UpperCAmelCase_				( __UpperCAmelCase		:      int				)   ->					int:
      assert isinstance(__UpperCAmelCase     ,     __UpperCAmelCase				), f"The input value of [n={number}] is not an integer"

      if number == 1:
            return 2
      elif number < 1:
            SCREAMING_SNAKE_CASE_      		=     f"The input value of [n={number}] has to be > 0"
            raise ValueError(__UpperCAmelCase				)
      else:
            SCREAMING_SNAKE_CASE_      		=     sylvester(number - 1				)
            SCREAMING_SNAKE_CASE_      		=     num - 1
            SCREAMING_SNAKE_CASE_      		=     num
            return lower * upper + 1


if __name__ == "__main__":
   print(f'''The 8th number in Sylvester\'s sequence: {sylvester(8)}''')