





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						:   List[Any]    ,  UpperCAmelCase						:   List[Any]    ,  UpperCAmelCase						:   Optional[Any]=13    ,  UpperCAmelCase						:   Optional[Any]=7    ,  UpperCAmelCase						:   Dict=True    ,  UpperCAmelCase						:   Any=True    ,  UpperCAmelCase						:   List[str]=True    ,  UpperCAmelCase						:   List[str]=True    ,  UpperCAmelCase						:   List[Any]=True    ,  UpperCAmelCase						:   Dict=False    ,  UpperCAmelCase						:   Dict=False    ,  UpperCAmelCase						:   List[Any]=False    ,  UpperCAmelCase						:   Tuple=2    ,  UpperCAmelCase						:   Tuple=99    ,  UpperCAmelCase						:   List[str]=0    ,  UpperCAmelCase						:   Optional[Any]=32    ,  UpperCAmelCase						:   Optional[int]=5    ,  UpperCAmelCase						:   Dict=4    ,  UpperCAmelCase						:   List[Any]=0.1    ,  UpperCAmelCase						:   List[str]=0.1    ,  UpperCAmelCase						:   Tuple=512    ,  UpperCAmelCase						:   Tuple=2    ,  UpperCAmelCase						:   List[str]=0.0_2    ,  UpperCAmelCase						:   Optional[Any]=2    ,  UpperCAmelCase						:   Union[str, Any]=4    ,  UpperCAmelCase						:   Any="last"    ,  UpperCAmelCase						:   Optional[Any]=True    ,  UpperCAmelCase						:   Dict=None    ,  UpperCAmelCase						:   Optional[int]=0    ,  )    ->			List[Any]:
     lowerCamelCase__					:   List[str]      				=	parent
     lowerCamelCase__					:   Optional[Any]      				=	batch_size
     lowerCamelCase__					:   int      				=	seq_length
     lowerCamelCase__					:   Union[str, Any]      				=	is_training
     lowerCamelCase__					:   Dict      				=	use_input_lengths
     lowerCamelCase__					:   str      				=	use_token_type_ids
     lowerCamelCase__					:   str      				=	use_labels
     lowerCamelCase__					:   int      				=	gelu_activation
     lowerCamelCase__					:   Optional[Any]      				=	sinusoidal_embeddings
     lowerCamelCase__					:   Optional[Any]      				=	causal
     lowerCamelCase__					:   Any      				=	asm
     lowerCamelCase__					:   Any      				=	n_langs
     lowerCamelCase__					:   Tuple      				=	vocab_size
     lowerCamelCase__					:   int      				=	n_special
     lowerCamelCase__					:   str      				=	hidden_size
     lowerCamelCase__					:   List[Any]      				=	num_hidden_layers
     lowerCamelCase__					:   List[Any]      				=	num_attention_heads
     lowerCamelCase__					:   str      				=	hidden_dropout_prob
     lowerCamelCase__					:   str      				=	attention_probs_dropout_prob
     lowerCamelCase__					:   Union[str, Any]      				=	max_position_embeddings
     lowerCamelCase__					:   List[Any]      				=	type_sequence_label_size
     lowerCamelCase__					:   int      				=	initializer_range
     lowerCamelCase__					:   List[str]      				=	num_labels
     lowerCamelCase__					:   List[Any]      				=	num_choices
     lowerCamelCase__					:   Optional[Any]      				=	summary_type
     lowerCamelCase__					:   Optional[Any]      				=	use_proj
     lowerCamelCase__					:   Dict      				=	scope
     lowerCamelCase__					:   List[str]      				=	bos_token_id
 def   A_			(   self						:   List[str]			)    ->			List[Any]:
     lowerCamelCase__					:   Optional[Any]      				=	ids_tensor([self.batch_size, self.seq_length]    ,  self.vocab_size			)
     lowerCamelCase__					:   Any      				=	random_attention_mask([self.batch_size, self.seq_length]			)

     lowerCamelCase__					:   List[str]      				=	None
     if self.use_input_lengths:
         lowerCamelCase__					:   Optional[int]      				=	(
             ids_tensor([self.batch_size]    ,  vocab_size=2			) + self.seq_length - 2
         )  # small variation of seq_length

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

     lowerCamelCase__					:   Union[str, Any]      				=	None
     lowerCamelCase__					:   Union[str, Any]      				=	None
     lowerCamelCase__					:   Union[str, Any]      				=	None
     if self.use_labels:
         lowerCamelCase__					:   Any      				=	ids_tensor([self.batch_size]    ,  self.type_sequence_label_size			)
         lowerCamelCase__					:   Dict      				=	ids_tensor([self.batch_size, self.seq_length]    ,  self.num_labels			)
         lowerCamelCase__					:   int      				=	ids_tensor([self.batch_size]    ,  2			).float()
         lowerCamelCase__					:   Any      				=	ids_tensor([self.batch_size]    ,  self.num_choices			)

     lowerCamelCase__					:   Union[str, Any]      				=	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			)    ->			List[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						:   Any    ,  UpperCAmelCase						:   Any    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   List[Any]    ,  UpperCAmelCase						:   Optional[Any]    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   str    ,  UpperCAmelCase						:   List[Any]    ,  )    ->			Union[str, Any]:
     lowerCamelCase__					:   str      				=	XLMModel(config=UpperCAmelCase			)
     model.to(UpperCAmelCase			)
     model.eval()
     lowerCamelCase__					:   Optional[int]      				=	model(UpperCAmelCase    ,  lengths=UpperCAmelCase    ,  langs=UpperCAmelCase			)
     lowerCamelCase__					:   List[str]      				=	model(UpperCAmelCase    ,  langs=UpperCAmelCase			)
     lowerCamelCase__					:   str      				=	model(UpperCAmelCase			)
     self.parent.assertEqual(result.last_hidden_state.shape    ,  (self.batch_size, self.seq_length, self.hidden_size)			)
 def   A_			(   self						:   Optional[Any]    ,  UpperCAmelCase						:   Union[str, Any]    ,  UpperCAmelCase						:   Dict    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   Union[str, Any]    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   Optional[Any]    ,  UpperCAmelCase						:   List[Any]    ,  UpperCAmelCase						:   Tuple    ,  UpperCAmelCase						:   List[Any]    ,  )    ->			str:
     lowerCamelCase__					:   int      				=	XLMWithLMHeadModel(UpperCAmelCase			)
     model.to(UpperCAmelCase			)
     model.eval()

     lowerCamelCase__					:   List[str]      				=	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						:   List[str]    ,  UpperCAmelCase						:   Union[str, Any]    ,  UpperCAmelCase						:   Tuple    ,  UpperCAmelCase						:   Dict    ,  UpperCAmelCase						:   Optional[Any]    ,  UpperCAmelCase						:   Tuple    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   Dict    ,  UpperCAmelCase						:   str    ,  )    ->			List[Any]:
     lowerCamelCase__					:   List[str]      				=	XLMForQuestionAnsweringSimple(UpperCAmelCase			)
     model.to(UpperCAmelCase			)
     model.eval()

     lowerCamelCase__					:   Tuple      				=	model(UpperCAmelCase			)

     lowerCamelCase__					:   Tuple      				=	model(UpperCAmelCase    ,  start_positions=UpperCAmelCase    ,  end_positions=UpperCAmelCase			)
     lowerCamelCase__					:   Union[str, Any]      				=	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						:   Tuple    ,  UpperCAmelCase						:   Tuple    ,  UpperCAmelCase						:   List[Any]    ,  UpperCAmelCase						:   Tuple    ,  UpperCAmelCase						:   Dict    ,  UpperCAmelCase						:   str    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   int    ,  )    ->			List[str]:
     lowerCamelCase__					:   Tuple      				=	XLMForQuestionAnswering(UpperCAmelCase			)
     model.to(UpperCAmelCase			)
     model.eval()

     lowerCamelCase__					:   List[str]      				=	model(UpperCAmelCase			)

     lowerCamelCase__					:   Optional[Any]      				=	model(
         UpperCAmelCase    ,  start_positions=UpperCAmelCase    ,  end_positions=UpperCAmelCase    ,  cls_index=UpperCAmelCase    ,  is_impossible=UpperCAmelCase    ,  p_mask=UpperCAmelCase    ,  )

     lowerCamelCase__					:   Dict      				=	model(
         UpperCAmelCase    ,  start_positions=UpperCAmelCase    ,  end_positions=UpperCAmelCase    ,  cls_index=UpperCAmelCase    ,  is_impossible=UpperCAmelCase    ,  )

     ((lowerCamelCase__)				,							)					:   str      				=	result_with_labels.to_tuple()

     lowerCamelCase__					:   List[str]      				=	model(UpperCAmelCase    ,  start_positions=UpperCAmelCase    ,  end_positions=UpperCAmelCase			)

     ((lowerCamelCase__)				,							)					:   Dict      				=	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						:   Union[str, Any]    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   Dict    ,  UpperCAmelCase						:   Tuple    ,  UpperCAmelCase						:   str    ,  UpperCAmelCase						:   Tuple    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   Any    ,  UpperCAmelCase						:   Union[str, Any]    ,  UpperCAmelCase						:   int    ,  )    ->			int:
     lowerCamelCase__					:   Union[str, Any]      				=	XLMForSequenceClassification(UpperCAmelCase			)
     model.to(UpperCAmelCase			)
     model.eval()

     lowerCamelCase__					:   Any      				=	model(UpperCAmelCase			)
     lowerCamelCase__					:   Dict      				=	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						:   str    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   Union[str, Any]    ,  UpperCAmelCase						:   Optional[Any]    ,  UpperCAmelCase						:   Union[str, Any]    ,  UpperCAmelCase						:   List[Any]    ,  UpperCAmelCase						:   Any    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   str    ,  )    ->			Optional[Any]:
     lowerCamelCase__					:   List[Any]      				=	self.num_labels
     lowerCamelCase__					:   Tuple      				=	XLMForTokenClassification(UpperCAmelCase			)
     model.to(UpperCAmelCase			)
     model.eval()

     lowerCamelCase__					:   List[Any]      				=	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						:   str    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   Any    ,  UpperCAmelCase						:   Tuple    ,  UpperCAmelCase						:   Optional[int]    ,  UpperCAmelCase						:   str    ,  UpperCAmelCase						:   Optional[int]    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   Dict    ,  UpperCAmelCase						:   Dict    ,  )    ->			List[Any]:
     lowerCamelCase__					:   Optional[int]      				=	self.num_choices
     lowerCamelCase__					:   int      				=	XLMForMultipleChoice(config=UpperCAmelCase			)
     model.to(UpperCAmelCase			)
     model.eval()
     lowerCamelCase__					:   List[str]      				=	input_ids.unsqueeze(1			).expand(-1    ,  self.num_choices    ,  -1			).contiguous()
     lowerCamelCase__					:   List[str]      				=	token_type_ids.unsqueeze(1			).expand(-1    ,  self.num_choices    ,  -1			).contiguous()
     lowerCamelCase__					:   Tuple      				=	input_mask.unsqueeze(1			).expand(-1    ,  self.num_choices    ,  -1			).contiguous()
     lowerCamelCase__					:   List[str]      				=	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[Any]			)    ->			Union[str, Any]:
     lowerCamelCase__					:   Dict      				=	self.prepare_config_and_inputs()
     (
         (
         lowerCamelCase__
     )				,							(
         lowerCamelCase__
     )				,							(
         lowerCamelCase__
     )				,							(
         lowerCamelCase__
     )				,							(
         lowerCamelCase__
     )				,							(
         lowerCamelCase__
     )				,							(
         lowerCamelCase__
     )				,							(
         lowerCamelCase__
     )				,							(
         lowerCamelCase__
     )				,							
     )					:   List[str]      				=	config_and_inputs
     lowerCamelCase__					:   int      				=	{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'lengths': input_lengths}
     return config, inputs_dict


@require_torch
class      lowerCAmelCase							(      __UpperCamelCase,						__UpperCamelCase,						__UpperCamelCase,						unittest.TestCase    ):
 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						:   Dict    ,  UpperCAmelCase						:   Union[str, Any]    ,  UpperCAmelCase						:   str    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   Optional[int]    ,  UpperCAmelCase						:   Tuple			)    ->			Optional[int]:
     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						:   Tuple    ,  UpperCAmelCase						:   Optional[int]    ,  UpperCAmelCase						:   Optional[int]    ,  UpperCAmelCase						:   Optional[int]=False			)    ->			Tuple:
     lowerCamelCase__					:   List[str]      				=	super()._prepare_for_class(UpperCAmelCase    ,  UpperCAmelCase    ,  return_labels=UpperCAmelCase			)

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

     return inputs_dict
 def   A_			(   self						:   str			)    ->			Union[str, Any]:
     lowerCamelCase__					:   Union[str, Any]      				=	XLMModelTester(self			)
     lowerCamelCase__					:   Any      				=	ConfigTester(self    ,  config_class=UpperCAmelCase    ,  emb_dim=37			)
 def   A_			(   self						:   Optional[int]			)    ->			List[Any]:
     self.config_tester.run_common_tests()
 def   A_			(   self						:   Any			)    ->			List[Any]:
     lowerCamelCase__					:   Any      				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_model(*UpperCAmelCase			)
 def   A_			(   self						:   str			)    ->			Any:
     lowerCamelCase__					:   int      				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_lm_head(*UpperCAmelCase			)
 def   A_			(   self						:   Dict			)    ->			Optional[Any]:
     lowerCamelCase__					:   str      				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_simple_qa(*UpperCAmelCase			)
 def   A_			(   self						:   Optional[Any]			)    ->			Optional[Any]:
     lowerCamelCase__					:   Optional[Any]      				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_qa(*UpperCAmelCase			)
 def   A_			(   self						:   Any			)    ->			Optional[int]:
     lowerCamelCase__					:   List[str]      				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_sequence_classif(*UpperCAmelCase			)
 def   A_			(   self						:   Any			)    ->			str:
     lowerCamelCase__					:   List[Any]      				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_token_classif(*UpperCAmelCase			)
 def   A_			(   self						:   Any			)    ->			Optional[int]:
     lowerCamelCase__					:   List[Any]      				=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCAmelCase			)
 def   A_			(   self						:   Optional[int]    ,  UpperCAmelCase						:   List[Any]    ,  UpperCAmelCase						:   Tuple    ,  UpperCAmelCase						:   Any    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   Any    ,  UpperCAmelCase						:   List[Any]=False    ,  UpperCAmelCase						:   str=1			)    ->			Union[str, Any]:
     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
         lowerCamelCase__					:   Any      				=	min_length + idx + 1
         lowerCamelCase__					:   Union[str, Any]      				=	min_length + idx + 1

         lowerCamelCase__					:   Optional[Any]      				=	(
             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						:   str    ,  UpperCAmelCase						:   Optional[int]    ,  UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   Optional[int]    ,  UpperCAmelCase						:   str    ,  UpperCAmelCase						:   Dict    ,  UpperCAmelCase						:   List[str]=False    ,  UpperCAmelCase						:   Tuple=1			)    ->			Union[str, Any]:
     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
         lowerCamelCase__					:   str      				=	min_length + idx + 1
         lowerCamelCase__					:   Any      				=	(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						:   Optional[Any]			)    ->			Union[str, Any]:
     for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCamelCase__					:   Dict      				=	XLMModel.from_pretrained(UpperCAmelCase			)
         self.assertIsNotNone(UpperCAmelCase			)


@require_torch
class      lowerCAmelCase							(      unittest.TestCase    ):
 @slow
 def   A_			(   self						:   Any			)    ->			List[Any]:
     lowerCamelCase__					:   Dict      				=	XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'			)
     model.to(UpperCAmelCase			)
     lowerCamelCase__					:   int      				=	torch.tensor([[14, 447]]    ,  dtype=torch.long    ,  device=UpperCAmelCase			)  # the president
     lowerCamelCase__					:   Tuple      				=	[
         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[Any]      				=	model.generate(UpperCAmelCase    ,  do_sample=UpperCAmelCase			)
     self.assertListEqual(output_ids[0].cpu().numpy().tolist()    ,  UpperCAmelCase			)












_UpperCAmelCase       : List[Any]			     =       {
    """meter""": """m""",
    """kilometer""": """km""",
    """megametre""": """Mm""",
    """gigametre""": """Gm""",
    """terametre""": """Tm""",
    """petametre""": """Pm""",
    """exametre""": """Em""",
    """zettametre""": """Zm""",
    """yottametre""": """Ym""",
}
# Exponent of the factor(meter)
_UpperCAmelCase       : Dict			     =       {
    """m""": 0,
    """km""": 3,
    """Mm""": 6,
    """Gm""": 9,
    """Tm""": 12,
    """Pm""": 15,
    """Em""": 18,
    """Zm""": 21,
    """Ym""": 24,
}


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase				)    ->  float:
    lowerCamelCase__					:   Dict      				=	from_type.lower().strip('s'				)
    lowerCamelCase__					:   Dict      				=	to_type.lower().strip('s'				)

    lowerCamelCase__					:   Dict      				=	UNIT_SYMBOL.get(_UpperCAmelCase		,			_UpperCAmelCase				)
    lowerCamelCase__					:   str      				=	UNIT_SYMBOL.get(_UpperCAmelCase		,			_UpperCAmelCase				)

    if from_sanitized not in METRIC_CONVERSION:
        lowerCamelCase__					:   List[Any]      				=	(
            F"""Invalid 'from_type' value: {from_type!r}.\n"""
            F"""Conversion abbreviations are: {", ".join(_UpperCAmelCase				)}"""
        )
        raise ValueError(_UpperCAmelCase				)
    if to_sanitized not in METRIC_CONVERSION:
        lowerCamelCase__					:   Optional[Any]      				=	(
            F"""Invalid 'to_type' value: {to_type!r}.\n"""
            F"""Conversion abbreviations are: {", ".join(_UpperCAmelCase				)}"""
        )
        raise ValueError(_UpperCAmelCase				)
    lowerCamelCase__					:   Any      				=	METRIC_CONVERSION[from_sanitized]
    lowerCamelCase__					:   Optional[int]      				=	METRIC_CONVERSION[to_sanitized]
    lowerCamelCase__					:   List[str]      				=	1

    if from_exponent > to_exponent:
        lowerCamelCase__					:   Dict      				=	from_exponent - to_exponent
    else:
        lowerCamelCase__					:   Dict      				=	-(to_exponent - from_exponent)

    return value * pow(10		,			_UpperCAmelCase				)


if __name__ == "__main__":
    from doctest import testmod

    testmod()





