


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





     def __init__(self		,     UpperCAmelCase		,     UpperCAmelCase=1_3		,     UpperCAmelCase=7		,     UpperCAmelCase=True		,     UpperCAmelCase=True		,     UpperCAmelCase=True		,     UpperCAmelCase=True		,     UpperCAmelCase=True		,     UpperCAmelCase=False		,     UpperCAmelCase=False		,     UpperCAmelCase=False		,     UpperCAmelCase=2		,     UpperCAmelCase=9_9		,     UpperCAmelCase=0		,     UpperCAmelCase=3_2		,     UpperCAmelCase=5		,     UpperCAmelCase=4		,     UpperCAmelCase=0.1		,     UpperCAmelCase=0.1		,     UpperCAmelCase=5_1_2		,     UpperCAmelCase=2		,     UpperCAmelCase=0.02		,     UpperCAmelCase=2		,     UpperCAmelCase=4		,     UpperCAmelCase="last"		,     UpperCAmelCase=True		,     UpperCAmelCase=None		,     UpperCAmelCase=0		,     )     ->   List[Any]:
      _lowercase							      =parent
      _lowercase							      =batch_size
      _lowercase							      =seq_length
      _lowercase							      =is_training
      _lowercase							      =use_input_lengths
      _lowercase							      =use_token_type_ids
      _lowercase							      =use_labels
      _lowercase							      =gelu_activation
      _lowercase							      =sinusoidal_embeddings
      _lowercase							      =causal
      _lowercase							      =asm
      _lowercase							      =n_langs
      _lowercase							      =vocab_size
      _lowercase							      =n_special
      _lowercase							      =hidden_size
      _lowercase							      =num_hidden_layers
      _lowercase							      =num_attention_heads
      _lowercase							      =hidden_dropout_prob
      _lowercase							      =attention_probs_dropout_prob
      _lowercase							      =max_position_embeddings
      _lowercase							      =type_sequence_label_size
      _lowercase							      =initializer_range
      _lowercase							      =num_labels
      _lowercase							      =num_choices
      _lowercase							      =summary_type
      _lowercase							      =use_proj
      _lowercase							      =scope
      _lowercase							      =bos_token_id





     def      __A					(self       )     ->   Dict:
      _lowercase							      =ids_tensor([self.batch_size, self.seq_length]		,     self.vocab_size       )
      _lowercase							      =random_attention_mask([self.batch_size, self.seq_length]       )

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

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

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

      _lowercase							      =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       )     ->   str:
      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		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     )     ->   Dict:
      _lowercase							      =XLMModel(config=UpperCAmelCase       )
      model.to(UpperCAmelCase       )
      model.eval()
      _lowercase							      =model(UpperCAmelCase		,     lengths=UpperCAmelCase		,     langs=UpperCAmelCase       )
      _lowercase							      =model(UpperCAmelCase		,     langs=UpperCAmelCase       )
      _lowercase							      =model(UpperCAmelCase       )
      self.parent.assertEqual(result.last_hidden_state.shape		,     (self.batch_size, self.seq_length, self.hidden_size)       )





     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     )     ->   Dict:
      _lowercase							      =XLMWithLMHeadModel(UpperCAmelCase       )
      model.to(UpperCAmelCase       )
      model.eval()

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





     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     )     ->   List[Any]:
      _lowercase							      =XLMForQuestionAnsweringSimple(UpperCAmelCase       )
      model.to(UpperCAmelCase       )
      model.eval()

      _lowercase							      =model(UpperCAmelCase       )

      _lowercase							      =model(UpperCAmelCase		,     start_positions=UpperCAmelCase		,     end_positions=UpperCAmelCase       )
      _lowercase							      =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		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     )     ->   Optional[int]:
      _lowercase							      =XLMForQuestionAnswering(UpperCAmelCase       )
      model.to(UpperCAmelCase       )
      model.eval()

      _lowercase							      =model(UpperCAmelCase       )

      _lowercase							      =model(
          UpperCAmelCase		,     start_positions=UpperCAmelCase		,     end_positions=UpperCAmelCase		,     cls_index=UpperCAmelCase		,     is_impossible=UpperCAmelCase		,     p_mask=UpperCAmelCase		,     )

      _lowercase							      =model(
          UpperCAmelCase		,     start_positions=UpperCAmelCase		,     end_positions=UpperCAmelCase		,     cls_index=UpperCAmelCase		,     is_impossible=UpperCAmelCase		,     )

      ((_lowercase)      ,    )							      =result_with_labels.to_tuple()

      _lowercase							      =model(UpperCAmelCase		,     start_positions=UpperCAmelCase		,     end_positions=UpperCAmelCase       )

      ((_lowercase)      ,    )							      =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		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     )     ->   int:
      _lowercase							      =XLMForSequenceClassification(UpperCAmelCase       )
      model.to(UpperCAmelCase       )
      model.eval()

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





     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     )     ->   Dict:
      _lowercase							      =self.num_labels
      _lowercase							      =XLMForTokenClassification(UpperCAmelCase       )
      model.to(UpperCAmelCase       )
      model.eval()

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





     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     )     ->   List[str]:
      _lowercase							      =self.num_choices
      _lowercase							      =XLMForMultipleChoice(config=UpperCAmelCase       )
      model.to(UpperCAmelCase       )
      model.eval()
      _lowercase							      =input_ids.unsqueeze(1       ).expand(-1		,     self.num_choices		,     -1       ).contiguous()
      _lowercase							      =token_type_ids.unsqueeze(1       ).expand(-1		,     self.num_choices		,     -1       ).contiguous()
      _lowercase							      =input_mask.unsqueeze(1       ).expand(-1		,     self.num_choices		,     -1       ).contiguous()
      _lowercase							      =model(
          UpperCAmelCase		,     attention_mask=UpperCAmelCase		,     token_type_ids=UpperCAmelCase		,     labels=UpperCAmelCase		,     )
      self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_choices)       )





     def      __A					(self       )     ->   Optional[int]:
      _lowercase							      =self.prepare_config_and_inputs()
      (
          (
          _lowercase
      )      ,    (
          _lowercase
      )      ,    (
          _lowercase
      )      ,    (
          _lowercase
      )      ,    (
          _lowercase
      )      ,    (
          _lowercase
      )      ,    (
          _lowercase
      )      ,    (
          _lowercase
      )      ,    (
          _lowercase
      )      ,    
      )							      =config_and_inputs
      _lowercase							      ={'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''lengths''': input_lengths}
      return config, inputs_dict







@require_torch
class       lowerCamelCase__   (       lowerCAmelCase   ,							lowerCAmelCase   ,							lowerCAmelCase   ,							unittest.TestCase):
     SCREAMING_SNAKE_CASE__      			=			(
         (
             XLMModel,
             XLMWithLMHeadModel,
             XLMForQuestionAnswering,
             XLMForSequenceClassification,
             XLMForQuestionAnsweringSimple,
             XLMForTokenClassification,
             XLMForMultipleChoice,
         )
         if is_torch_available()
         else ()
     )
     SCREAMING_SNAKE_CASE__      			=			(
         (XLMWithLMHeadModel,) if is_torch_available() else ()
     )  # TODO (PVP): Check other models whether language generation is also applicable
     SCREAMING_SNAKE_CASE__      			=			(
         {
             '''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		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase       )     ->   Any:
      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		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase=False       )     ->   List[Any]:
      _lowercase							      =super()._prepare_for_class(UpperCAmelCase		,     UpperCAmelCase		,     return_labels=UpperCAmelCase       )

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

      return inputs_dict





     def      __A					(self       )     ->   List[Any]:
      _lowercase							      =XLMModelTester(self       )
      _lowercase							      =ConfigTester(self		,     config_class=UpperCAmelCase		,     emb_dim=3_7       )





     def      __A					(self       )     ->   List[Any]:
      self.config_tester.run_common_tests()





     def      __A					(self       )     ->   List[Any]:
      _lowercase							      =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_model(*UpperCAmelCase       )





     def      __A					(self       )     ->   str:
      _lowercase							      =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_lm_head(*UpperCAmelCase       )





     def      __A					(self       )     ->   Any:
      _lowercase							      =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_simple_qa(*UpperCAmelCase       )





     def      __A					(self       )     ->   int:
      _lowercase							      =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_qa(*UpperCAmelCase       )





     def      __A					(self       )     ->   Union[str, Any]:
      _lowercase							      =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_sequence_classif(*UpperCAmelCase       )





     def      __A					(self       )     ->   Tuple:
      _lowercase							      =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_token_classif(*UpperCAmelCase       )





     def      __A					(self       )     ->   Tuple:
      _lowercase							      =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCAmelCase       )





     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase=False		,     UpperCAmelCase=1       )     ->   str:
      self.assertIsInstance(UpperCAmelCase		,     UpperCAmelCase       )
      self.assertListEqual(
          [isinstance(UpperCAmelCase		,     UpperCAmelCase       ) for iter_attentions in attentions]		,     [True] * len(UpperCAmelCase       )       )
      self.assertEqual(len(UpperCAmelCase       )		,     (max_length - min_length) * num_beam_groups       )

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

       _lowercase							      =(
           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(UpperCAmelCase       )       )





     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase=False		,     UpperCAmelCase=1       )     ->   int:
      self.assertIsInstance(UpperCAmelCase		,     UpperCAmelCase       )
      self.assertListEqual(
          [isinstance(UpperCAmelCase		,     UpperCAmelCase       ) for iter_hidden_states in hidden_states]		,     [True] * len(UpperCAmelCase       )		,     )
      self.assertEqual(len(UpperCAmelCase       )		,     (max_length - min_length) * num_beam_groups       )

      for idx, iter_hidden_states in enumerate(UpperCAmelCase       ):
       # adds PAD dummy token
       _lowercase							      =min_length + idx + 1
       _lowercase							      =(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(UpperCAmelCase       )		,     )
      pass





     @slow
     def      __A					(self       )     ->   Union[str, Any]:
      for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       _lowercase							      =XLMModel.from_pretrained(UpperCAmelCase       )
       self.assertIsNotNone(UpperCAmelCase       )







@require_torch
class       lowerCamelCase__   (       unittest.TestCase):





     @slow
     def      __A					(self       )     ->   Union[str, Any]:
      _lowercase							      =XLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''       )
      model.to(UpperCAmelCase       )
      _lowercase							      =torch.tensor([[1_4, 4_4_7]]		,     dtype=torch.long		,     device=UpperCAmelCase       )  # the president
      _lowercase							      =[
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
      ]  # 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
      _lowercase							      =model.generate(UpperCAmelCase		,     do_sample=UpperCAmelCase       )
      self.assertListEqual(output_ids[0].cpu().numpy().tolist()		,     UpperCAmelCase       )





def 				UpperCAmelCase_					(							__snake_case						)     ->			str:







 """simple docstring"""


 _lowercase							      =0

 # if input_string is "aba" than new_input_string become "a|b|a"
 _lowercase							      =''''''
 _lowercase							      =''''''

 # append each character + "|" in new_string for range(0, length-1)
 for i in input_string[: len(__snake_case						) - 1]:
  new_input_string += i + "|"
 # append last character
 new_input_string += input_string[-1]

 # we will store the starting and ending of previous furthest ending palindromic
 # substring
 _lowercase      ,    _lowercase							      =0, 0

 # length[i] shows the length of palindromic substring with center i
 _lowercase							      =[1 for i in range(len(__snake_case						)						)]

 # for each character in new_string find corresponding palindromic string
 _lowercase							      =0
 for j in range(len(__snake_case						)						):
  _lowercase							      =1 if j > r else min(length[l + r - j] // 2     ,						r - j + 1						)
  while (
      j - k >= 0
      and j + k < len(__snake_case						)
      and new_input_string[k + j] == new_input_string[j - k]
  ):
   k += 1

  _lowercase							      =2 * k - 1

  # does this string is ending after the previously explored end (that is r) ?
  # if yes the update the new r to the last index of this
  if j + k - 1 > r:
   _lowercase							      =j - k + 1  # noqa: E741
   _lowercase							      =j + k - 1

  # update max_length and start position
  if max_length < length[j]:
   _lowercase							      =length[j]
   _lowercase							      =j

    # create that string
 _lowercase							      =new_input_string[start - max_length // 2 : start + max_length // 2 + 1]
 for i in s:
  if i != "|":
   output_string += i

 return output_string


if __name__ == "__main__":
  import doctest

  doctest.testmod()

