"""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 						__UpperCAmelCase    :







			'''simple docstring'''





			def __init__(			self   ,      snake_case_   ,      snake_case_=13   ,      snake_case_=7   ,      snake_case_=True   ,      snake_case_=True   ,      snake_case_=True   ,      snake_case_=True   ,      snake_case_=True   ,      snake_case_=False   ,      snake_case_=False   ,      snake_case_=False   ,      snake_case_=2   ,      snake_case_=99   ,      snake_case_=0   ,      snake_case_=32   ,      snake_case_=5   ,      snake_case_=4   ,      snake_case_=0.1   ,      snake_case_=0.1   ,      snake_case_=512   ,      snake_case_=2   ,      snake_case_=0.02   ,      snake_case_=2   ,      snake_case_=4   ,      snake_case_="last"   ,      snake_case_=True   ,      snake_case_=None   ,      snake_case_=0   ,      ):







										'''simple docstring'''


										A__       :     Tuple								=			parent
										A__       :     List[str]								=			batch_size
										A__       :     Optional[Any]								=			seq_length
										A__       :     Optional[Any]								=			is_training
										A__       :     Tuple								=			use_input_lengths
										A__       :     Union[str, Any]								=			use_token_type_ids
										A__       :     Dict								=			use_labels
										A__       :     Any								=			gelu_activation
										A__       :     Tuple								=			sinusoidal_embeddings
										A__       :     str								=			causal
										A__       :     List[str]								=			asm
										A__       :     str								=			n_langs
										A__       :     Tuple								=			vocab_size
										A__       :     List[str]								=			n_special
										A__       :     Union[str, Any]								=			hidden_size
										A__       :     Any								=			num_hidden_layers
										A__       :     int								=			num_attention_heads
										A__       :     Optional[Any]								=			hidden_dropout_prob
										A__       :     List[Any]								=			attention_probs_dropout_prob
										A__       :     List[str]								=			max_position_embeddings
										A__       :     Dict								=			type_sequence_label_size
										A__       :     Any								=			initializer_range
										A__       :     List[str]								=			num_labels
										A__       :     List[Any]								=			num_choices
										A__       :     Any								=			summary_type
										A__       :     int								=			use_proj
										A__       :     str								=			scope
										A__       :     str								=			bos_token_id





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     int								=			ids_tensor([self.batch_size, self.seq_length]   ,      self.vocab_size							)
										A__       :     Optional[Any]								=			random_attention_mask([self.batch_size, self.seq_length]							)

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

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

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

										A__       :     str								=			self.get_config()

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





			def 		lowerCamelCase					(			self							):







										'''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 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      ):







										'''simple docstring'''


										A__       :     int								=			XLMModel(config=snake_case_							)
										model.to(snake_case_							)
										model.eval()
										A__       :     Optional[int]								=			model(snake_case_   ,      lengths=snake_case_   ,      langs=snake_case_							)
										A__       :     Dict								=			model(snake_case_   ,      langs=snake_case_							)
										A__       :     Union[str, Any]								=			model(snake_case_							)
										self.parent.assertEqual(result.last_hidden_state.shape   ,      (self.batch_size, self.seq_length, self.hidden_size)							)





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      ):







										'''simple docstring'''


										A__       :     List[Any]								=			XLMWithLMHeadModel(snake_case_							)
										model.to(snake_case_							)
										model.eval()

										A__       :     Any								=			model(snake_case_   ,      token_type_ids=snake_case_   ,      labels=snake_case_							)
										self.parent.assertEqual(result.loss.shape   ,      ()							)
										self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.seq_length, self.vocab_size)							)





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      ):







										'''simple docstring'''


										A__       :     Optional[int]								=			XLMForQuestionAnsweringSimple(snake_case_							)
										model.to(snake_case_							)
										model.eval()

										A__       :     str								=			model(snake_case_							)

										A__       :     Dict								=			model(snake_case_   ,      start_positions=snake_case_   ,      end_positions=snake_case_							)
										A__       :     Optional[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 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      ):







										'''simple docstring'''


										A__       :     Tuple								=			XLMForQuestionAnswering(snake_case_							)
										model.to(snake_case_							)
										model.eval()

										A__       :     Tuple								=			model(snake_case_							)

										A__       :     Tuple								=			model(
										    snake_case_   ,      start_positions=snake_case_   ,      end_positions=snake_case_   ,      cls_index=snake_case_   ,      is_impossible=snake_case_   ,      p_mask=snake_case_   ,      )

										A__       :     List[str]								=			model(
										    snake_case_   ,      start_positions=snake_case_   ,      end_positions=snake_case_   ,      cls_index=snake_case_   ,      is_impossible=snake_case_   ,      )

										((A__)				,							)       :     Tuple								=			result_with_labels.to_tuple()

										A__       :     Dict								=			model(snake_case_   ,      start_positions=snake_case_   ,      end_positions=snake_case_							)

										((A__)				,							)       :     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 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      ):







										'''simple docstring'''


										A__       :     Tuple								=			XLMForSequenceClassification(snake_case_							)
										model.to(snake_case_							)
										model.eval()

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





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      ):







										'''simple docstring'''


										A__       :     List[str]								=			self.num_labels
										A__       :     Union[str, Any]								=			XLMForTokenClassification(snake_case_							)
										model.to(snake_case_							)
										model.eval()

										A__       :     List[Any]								=			model(snake_case_   ,      attention_mask=snake_case_   ,      labels=snake_case_							)
										self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.seq_length, self.num_labels)							)





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      ):







										'''simple docstring'''


										A__       :     Tuple								=			self.num_choices
										A__       :     Dict								=			XLMForMultipleChoice(config=snake_case_							)
										model.to(snake_case_							)
										model.eval()
										A__       :     Optional[Any]								=			input_ids.unsqueeze(1							).expand(-1   ,      self.num_choices   ,      -1							).contiguous()
										A__       :     Dict								=			token_type_ids.unsqueeze(1							).expand(-1   ,      self.num_choices   ,      -1							).contiguous()
										A__       :     str								=			input_mask.unsqueeze(1							).expand(-1   ,      self.num_choices   ,      -1							).contiguous()
										A__       :     Dict								=			model(
										    snake_case_   ,      attention_mask=snake_case_   ,      token_type_ids=snake_case_   ,      labels=snake_case_   ,      )
										self.parent.assertEqual(result.logits.shape   ,      (self.batch_size, self.num_choices)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[int]								=			self.prepare_config_and_inputs()
										(
										    (
										    A__
										)				,							(
										    A__
										)				,							(
										    A__
										)				,							(
										    A__
										)				,							(
										    A__
										)				,							(
										    A__
										)				,							(
										    A__
										)				,							(
										    A__
										)				,							(
										    A__
										)				,							
										)       :     List[str]								=			config_and_inputs
										A__       :     Optional[int]								=			{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """lengths""": input_lengths}
										return config, inputs_dict





@require_torch
class 						__UpperCAmelCase    (__A							,   __A							,   __A							,   unittest.TestCase     ):







			'''simple docstring'''
			_UpperCamelCase  :						str					     =				(
			    (
			        XLMModel,
			        XLMWithLMHeadModel,
			        XLMForQuestionAnswering,
			        XLMForSequenceClassification,
			        XLMForQuestionAnsweringSimple,
			        XLMForTokenClassification,
			        XLMForMultipleChoice,
			    )
			    if is_torch_available()
			    else ()
			)
			_UpperCamelCase  :						str					     =				(
			    (XLMWithLMHeadModel,) if is_torch_available() else ()
			)  # TODO (PVP): Check other models whether language generation is also applicable
			_UpperCamelCase  :						List[Any]					     =				(
			    {
			        '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 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										if (
										    pipeline_test_casse_name == "QAPipelineTests"
										    and tokenizer_name is not None
										    and not tokenizer_name.endswith("""Fast"""							)
										):
																	# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
																	# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
																	# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
																	return True

										return False





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_=False							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			super()._prepare_for_class(snake_case_   ,      snake_case_   ,      return_labels=snake_case_							)

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

										return inputs_dict





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			XLMModelTester(self							)
										A__       :     Tuple								=			ConfigTester(self   ,      config_class=snake_case_   ,      emb_dim=37							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										self.config_tester.run_common_tests()





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Any								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_model(*snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_lm_head(*snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Any								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_simple_qa(*snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Tuple								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_qa(*snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Any								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_sequence_classif(*snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[str]								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_token_classif(*snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[str]								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case_							)





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_=False   ,      snake_case_=1							):







										'''simple docstring'''


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

										for idx, iter_attentions in enumerate(snake_case_							):
																	# adds PAD dummy token
																	A__       :     Tuple								=			min_length + idx + 1
																	A__       :     Tuple								=			min_length + idx + 1

																	A__       :     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(snake_case_							)							)





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_=False   ,      snake_case_=1							):







										'''simple docstring'''


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

										for idx, iter_hidden_states in enumerate(snake_case_							):
																	# adds PAD dummy token
																	A__       :     List[str]								=			min_length + idx + 1
																	A__       :     Optional[int]								=			(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(snake_case_							)   ,      )
										pass





			@slow
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	A__       :     Union[str, Any]								=			XLMModel.from_pretrained(snake_case_							)
																	self.assertIsNotNone(snake_case_							)





@require_torch
class 						__UpperCAmelCase    (unittest.TestCase     ):







			'''simple docstring'''





			@slow
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


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






"""simple docstring"""



from __future__ import annotations

def  _A(		lowerCAmelCase							):
							if len(lowerCAmelCase							) == 0:
														return []
							A__				,							A__       :     Dict								=			min(lowerCAmelCase							), max(lowerCAmelCase							)
							A__       :     List[Any]								=			int(max_value - min_value							) + 1
							A__       :     list[list]								=			[[] for _ in range(lowerCAmelCase							)]

							for i in my_list:
														buckets[int(i - min_value							)].append(lowerCAmelCase							)

							return [v for bucket in buckets for v in sorted(lowerCAmelCase							)]


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

				testmod()
				assert bucket_sort([4, 5, 3, 2, 1]) == [1, 2, 3, 4, 5]
				assert bucket_sort([0, 1, -10, 15, 2, -2]) == [-10, -2, 0, 1, 2, 15]





