



"""simple docstring"""







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  :



			def __init__(			self							:				Dict   ,	_lowercase							:				Dict   ,	_lowercase							:				Optional[int]=13   ,	_lowercase							:				Tuple=7   ,	_lowercase							:				int=True   ,	_lowercase							:				Optional[int]=True   ,	_lowercase							:				int=True   ,	_lowercase							:				Union[str, Any]=True   ,	_lowercase							:				str=True   ,	_lowercase							:				List[str]=False   ,	_lowercase							:				Dict=False   ,	_lowercase							:				Optional[Any]=False   ,	_lowercase							:				Dict=2   ,	_lowercase							:				Union[str, Any]=99   ,	_lowercase							:				Optional[Any]=0   ,	_lowercase							:				List[str]=32   ,	_lowercase							:				Optional[int]=5   ,	_lowercase							:				int=4   ,	_lowercase							:				Tuple=0.1   ,	_lowercase							:				List[str]=0.1   ,	_lowercase							:				List[str]=512   ,	_lowercase							:				List[Any]=2   ,	_lowercase							:				Any=0.02   ,	_lowercase							:				Tuple=2   ,	_lowercase							:				List[Any]=4   ,	_lowercase							:				List[Any]="last"   ,	_lowercase							:				List[Any]=True   ,	_lowercase							:				Tuple=None   ,	_lowercase							:				int=0   ,	)							->					Optional[int]:
									snake_case   :			int						    = parent
									snake_case   :			Optional[Any]						    = batch_size
									snake_case   :			Optional[int]						    = seq_length
									snake_case   :			Union[str, Any]						    = is_training
									snake_case   :			int						    = use_input_lengths
									snake_case   :			Optional[Any]						    = use_token_type_ids
									snake_case   :			str						    = use_labels
									snake_case   :			Optional[Any]						    = gelu_activation
									snake_case   :			int						    = sinusoidal_embeddings
									snake_case   :			Any						    = causal
									snake_case   :			List[str]						    = asm
									snake_case   :			str						    = n_langs
									snake_case   :			Optional[int]						    = vocab_size
									snake_case   :			List[Any]						    = n_special
									snake_case   :			List[str]						    = hidden_size
									snake_case   :			Optional[Any]						    = num_hidden_layers
									snake_case   :			Dict						    = num_attention_heads
									snake_case   :			List[Any]						    = hidden_dropout_prob
									snake_case   :			str						    = attention_probs_dropout_prob
									snake_case   :			List[Any]						    = max_position_embeddings
									snake_case   :			Tuple						    = type_sequence_label_size
									snake_case   :			Optional[int]						    = initializer_range
									snake_case   :			Union[str, Any]						    = num_labels
									snake_case   :			Union[str, Any]						    = num_choices
									snake_case   :			str						    = summary_type
									snake_case   :			str						    = use_proj
									snake_case   :			Optional[Any]						    = scope
									snake_case   :			List[Any]						    = bos_token_id



			def 				__lowercase					(			self							:				str		)							->					List[Any]:
									snake_case   :			int						    = ids_tensor([self.batch_size, self.seq_length]   ,	self.vocab_size		)
									snake_case   :			List[str]						    = random_attention_mask([self.batch_size, self.seq_length]		)

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

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

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

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



			def 				__lowercase					(			self							:				List[Any]   ,	_lowercase							:				int   ,	_lowercase							:				Dict   ,	_lowercase							:				List[Any]   ,	_lowercase							:				str   ,	_lowercase							:				Tuple   ,	_lowercase							:				List[Any]   ,	_lowercase							:				List[Any]   ,	_lowercase							:				List[str]   ,	_lowercase							:				str   ,	)							->					List[Any]:
									snake_case   :			Union[str, Any]						    = XLMWithLMHeadModel(_lowercase		)
									model.to(_lowercase		)
									model.eval()

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



			def 				__lowercase					(			self							:				Optional[Any]   ,	_lowercase							:				Dict   ,	_lowercase							:				Any   ,	_lowercase							:				List[str]   ,	_lowercase							:				str   ,	_lowercase							:				Optional[int]   ,	_lowercase							:				str   ,	_lowercase							:				int   ,	_lowercase							:				Union[str, Any]   ,	_lowercase							:				Union[str, Any]   ,	)							->					List[str]:
									snake_case   :			Any						    = XLMForQuestionAnsweringSimple(_lowercase		)
									model.to(_lowercase		)
									model.eval()

									snake_case   :			Union[str, Any]						    = model(_lowercase		)

									snake_case   :			Optional[Any]						    = model(_lowercase   ,	start_positions=_lowercase   ,	end_positions=_lowercase		)
									snake_case   :			int						    = 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 				__lowercase					(			self							:				Any   ,	_lowercase							:				List[str]   ,	_lowercase							:				str   ,	_lowercase							:				int   ,	_lowercase							:				Dict   ,	_lowercase							:				str   ,	_lowercase							:				Any   ,	_lowercase							:				Tuple   ,	_lowercase							:				Tuple   ,	_lowercase							:				Tuple   ,	)							->					str:
									snake_case   :			Dict						    = XLMForQuestionAnswering(_lowercase		)
									model.to(_lowercase		)
									model.eval()

									snake_case   :			Dict						    = model(_lowercase		)

									snake_case   :			Union[str, Any]						    = model(
									    _lowercase   ,	start_positions=_lowercase   ,	end_positions=_lowercase   ,	cls_index=_lowercase   ,	is_impossible=_lowercase   ,	p_mask=_lowercase   ,	)

									snake_case   :			Union[str, Any]						    = model(
									    _lowercase   ,	start_positions=_lowercase   ,	end_positions=_lowercase   ,	cls_index=_lowercase   ,	is_impossible=_lowercase   ,	)

									((snake_case)    ,			)   :			Dict						    = result_with_labels.to_tuple()

									snake_case   :			Any						    = model(_lowercase   ,	start_positions=_lowercase   ,	end_positions=_lowercase		)

									((snake_case)    ,			)   :			Optional[int]						    = 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 				__lowercase					(			self							:				Tuple   ,	_lowercase							:				int   ,	_lowercase							:				str   ,	_lowercase							:				Dict   ,	_lowercase							:				str   ,	_lowercase							:				int   ,	_lowercase							:				List[Any]   ,	_lowercase							:				Any   ,	_lowercase							:				Union[str, Any]   ,	_lowercase							:				Dict   ,	)							->					Optional[Any]:
									snake_case   :			Optional[Any]						    = XLMForSequenceClassification(_lowercase		)
									model.to(_lowercase		)
									model.eval()

									snake_case   :			Optional[int]						    = model(_lowercase		)
									snake_case   :			Optional[int]						    = model(_lowercase   ,	labels=_lowercase		)
									self.parent.assertEqual(result.loss.shape   ,	()		)
									self.parent.assertEqual(result.logits.shape   ,	(self.batch_size, self.type_sequence_label_size)		)



			def 				__lowercase					(			self							:				Any   ,	_lowercase							:				List[Any]   ,	_lowercase							:				Tuple   ,	_lowercase							:				Optional[int]   ,	_lowercase							:				Dict   ,	_lowercase							:				List[str]   ,	_lowercase							:				Any   ,	_lowercase							:				Optional[Any]   ,	_lowercase							:				Any   ,	_lowercase							:				Optional[Any]   ,	)							->					Tuple:
									snake_case   :			Any						    = self.num_labels
									snake_case   :			Optional[Any]						    = XLMForTokenClassification(_lowercase		)
									model.to(_lowercase		)
									model.eval()

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



			def 				__lowercase					(			self							:				Tuple   ,	_lowercase							:				List[Any]   ,	_lowercase							:				Any   ,	_lowercase							:				int   ,	_lowercase							:				Dict   ,	_lowercase							:				Dict   ,	_lowercase							:				List[Any]   ,	_lowercase							:				Optional[Any]   ,	_lowercase							:				int   ,	_lowercase							:				Union[str, Any]   ,	)							->					Optional[Any]:
									snake_case   :			Optional[Any]						    = self.num_choices
									snake_case   :			int						    = XLMForMultipleChoice(config=_lowercase		)
									model.to(_lowercase		)
									model.eval()
									snake_case   :			Any						    = input_ids.unsqueeze(1		).expand(-1   ,	self.num_choices   ,	-1		).contiguous()
									snake_case   :			int						    = token_type_ids.unsqueeze(1		).expand(-1   ,	self.num_choices   ,	-1		).contiguous()
									snake_case   :			Tuple						    = input_mask.unsqueeze(1		).expand(-1   ,	self.num_choices   ,	-1		).contiguous()
									snake_case   :			List[str]						    = model(
									    _lowercase   ,	attention_mask=_lowercase   ,	token_type_ids=_lowercase   ,	labels=_lowercase   ,	)
									self.parent.assertEqual(result.logits.shape   ,	(self.batch_size, self.num_choices)		)



			def 				__lowercase					(			self							:				Optional[int]		)							->					int:
									snake_case   :			Any						    = self.prepare_config_and_inputs()
									(
									    (
									    snake_case
									)    ,			(
									    snake_case
									)    ,			(
									    snake_case
									)    ,			(
									    snake_case
									)    ,			(
									    snake_case
									)    ,			(
									    snake_case
									)    ,			(
									    snake_case
									)    ,			(
									    snake_case
									)    ,			(
									    snake_case
									)    ,			
									)   :			int						    = config_and_inputs
									snake_case   :			str						    = {"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
									return config, inputs_dict



@require_torch
class       _a  ( SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__     ,	unittest.TestCase):
			__magic_name__     					=     (
			    (
			        XLMModel,
			        XLMWithLMHeadModel,
			        XLMForQuestionAnswering,
			        XLMForSequenceClassification,
			        XLMForQuestionAnsweringSimple,
			        XLMForTokenClassification,
			        XLMForMultipleChoice,
			    )
			    if is_torch_available()
			    else ()
			)
			__magic_name__     					=     (
			    (XLMWithLMHeadModel,) if is_torch_available() else ()
			)  # TODO (PVP): Check other models whether language generation is also applicable
			__magic_name__     					=     (
			    {
			        """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 				__lowercase					(			self							:				Optional[Any]   ,	_lowercase							:				Dict   ,	_lowercase							:				Any   ,	_lowercase							:				List[Any]   ,	_lowercase							:				Optional[int]   ,	_lowercase							:				List[str]		)							->					Optional[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 				__lowercase					(			self							:				Any   ,	_lowercase							:				List[Any]   ,	_lowercase							:				int   ,	_lowercase							:				Tuple=False		)							->					int:
									snake_case   :			Dict						    = super()._prepare_for_class(_lowercase   ,	_lowercase   ,	return_labels=_lowercase		)

									if return_labels:
															if model_class.__name__ == "XLMForQuestionAnswering":
																					snake_case   :			List[str]						    = torch.zeros(
																					    self.model_tester.batch_size   ,	dtype=torch.long   ,	device=_lowercase		)
																					snake_case   :			int						    = torch.zeros(
																					    self.model_tester.batch_size   ,	dtype=torch.long   ,	device=_lowercase		)

									return inputs_dict



			def 				__lowercase					(			self							:				Dict		)							->					Tuple:
									snake_case   :			Union[str, Any]						    = XLMModelTester(self		)
									snake_case   :			int						    = ConfigTester(self   ,	config_class=_lowercase   ,	emb_dim=37		)



			def 				__lowercase					(			self							:				int		)							->					Optional[int]:
									self.config_tester.run_common_tests()



			def 				__lowercase					(			self							:				int		)							->					Optional[int]:
									snake_case   :			List[Any]						    = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_model(*_lowercase		)



			def 				__lowercase					(			self							:				int		)							->					List[str]:
									snake_case   :			Dict						    = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_lm_head(*_lowercase		)



			def 				__lowercase					(			self							:				str		)							->					Union[str, Any]:
									snake_case   :			Optional[int]						    = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_simple_qa(*_lowercase		)



			def 				__lowercase					(			self							:				str		)							->					int:
									snake_case   :			str						    = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_qa(*_lowercase		)



			def 				__lowercase					(			self							:				Union[str, Any]		)							->					Optional[int]:
									snake_case   :			Dict						    = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_sequence_classif(*_lowercase		)



			def 				__lowercase					(			self							:				Any		)							->					List[Any]:
									snake_case   :			Dict						    = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_token_classif(*_lowercase		)



			def 				__lowercase					(			self							:				str		)							->					Dict:
									snake_case   :			Optional[int]						    = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_xlm_for_multiple_choice(*_lowercase		)



			def 				__lowercase					(			self							:				Optional[Any]   ,	_lowercase							:				int   ,	_lowercase							:				Dict   ,	_lowercase							:				int   ,	_lowercase							:				str   ,	_lowercase							:				Dict   ,	_lowercase							:				int=False   ,	_lowercase							:				Optional[int]=1		)							->					str:
									self.assertIsInstance(_lowercase   ,	_lowercase		)
									self.assertListEqual(
									    [isinstance(_lowercase   ,	_lowercase		) for iter_attentions in attentions]   ,	[True] * len(_lowercase		)		)
									self.assertEqual(len(_lowercase		)   ,	(max_length - min_length) * num_beam_groups		)

									for idx, iter_attentions in enumerate(_lowercase		):
															# adds PAD dummy token
															snake_case   :			Tuple						    = min_length + idx + 1
															snake_case   :			List[Any]						    = min_length + idx + 1

															snake_case   :			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(_lowercase		)		)



			def 				__lowercase					(			self							:				int   ,	_lowercase							:				Any   ,	_lowercase							:				str   ,	_lowercase							:				List[str]   ,	_lowercase							:				Dict   ,	_lowercase							:				Optional[int]   ,	_lowercase							:				Optional[Any]=False   ,	_lowercase							:				Union[str, Any]=1		)							->					Any:
									self.assertIsInstance(_lowercase   ,	_lowercase		)
									self.assertListEqual(
									    [isinstance(_lowercase   ,	_lowercase		) for iter_hidden_states in hidden_states]   ,	[True] * len(_lowercase		)   ,	)
									self.assertEqual(len(_lowercase		)   ,	(max_length - min_length) * num_beam_groups		)

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



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



@require_torch
class       _a  ( unittest.TestCase):



			@slow
			def 				__lowercase					(			self							:				List[str]		)							->					Optional[int]:
									snake_case   :			str						    = XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"		)
									model.to(_lowercase		)
									snake_case   :			Optional[Any]						    = torch.tensor([[14, 447]]   ,	dtype=torch.long   ,	device=_lowercase		)  # the president
									snake_case   :			Optional[int]						    = [
									    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
									snake_case   :			Union[str, Any]						    = model.generate(_lowercase   ,	do_sample=_lowercase		)
									self.assertListEqual(output_ids[0].cpu().numpy().tolist()   ,	_lowercase		)








"""simple docstring"""







A		=						8.31_4462  # Unit - J mol-1 K-1

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							float     ,		lowerCamelCase_:							float     ,		lowerCamelCase_:							float ):
						"""simple docstring"""






						if moles < 0 or kelvin < 0 or volume < 0:
												raise ValueError("Invalid inputs. Enter positive value." )
						return moles * kelvin * UNIVERSAL_GAS_CONSTANT / volume

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							float     ,		lowerCamelCase_:							float     ,		lowerCamelCase_:							float ):
						"""simple docstring"""






						if moles < 0 or kelvin < 0 or pressure < 0:
												raise ValueError("Invalid inputs. Enter positive value." )
						return moles * kelvin * UNIVERSAL_GAS_CONSTANT / pressure


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

			testmod()



