"""simple docstring"""







from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import (
						    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFXLMForMultipleChoice,
						    TFXLMForQuestionAnsweringSimple,
						    TFXLMForSequenceClassification,
						    TFXLMForTokenClassification,
						    TFXLMModel,
						    TFXLMWithLMHeadModel,
						    XLMConfig,
						)


class       _lowercase		:

				def __init__(  self							:     Dict							,     _lowercase							:     Dict							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		parent
										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__       						=		2
										UpperCAmelCase__       						=		4
										UpperCAmelCase__       						=		0.1
										UpperCAmelCase__       						=		0.1
										UpperCAmelCase__       						=		5_1_2
										UpperCAmelCase__       						=		1_6
										UpperCAmelCase__       						=		2
										UpperCAmelCase__       						=		0.02
										UpperCAmelCase__       						=		3
										UpperCAmelCase__       						=		4
										UpperCAmelCase__       						=		"""last"""
										UpperCAmelCase__       						=		True
										UpperCAmelCase__       						=		None
										UpperCAmelCase__       						=		0

				def 							A			(  self							:     List[str]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.seq_length]							,     self.vocab_size  )
										UpperCAmelCase__       						=		random_attention_mask([self.batch_size, self.seq_length]							,     dtype=tf.floataa  )

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

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

										UpperCAmelCase__       						=		None
										UpperCAmelCase__       						=		None
										UpperCAmelCase__       						=		None
										if self.use_labels:
																UpperCAmelCase__       						=		ids_tensor([self.batch_size]							,     self.type_sequence_label_size  )
																UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.seq_length]							,     self.num_labels  )
																UpperCAmelCase__       						=		ids_tensor([self.batch_size]							,     2							,     dtype=tf.floataa  )
																UpperCAmelCase__       						=		ids_tensor([self.batch_size]							,     self.num_choices  )

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

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

				def 							A			(  self							:     Tuple							,     _lowercase							:     Tuple							,     _lowercase							:     Tuple							,     _lowercase							:     Any							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Optional[int]							,     _lowercase							:     List[str]							,     _lowercase							:     Tuple							,     _lowercase							:     Optional[Any]							,     _lowercase							:     List[Any]							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		TFXLMModel(config=_lowercase  )
										UpperCAmelCase__       						=		{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
										UpperCAmelCase__       						=		model(_lowercase  )

										UpperCAmelCase__       						=		[input_ids, input_mask]
										UpperCAmelCase__       						=		model(_lowercase  )
										self.parent.assertEqual(result.last_hidden_state.shape							,     (self.batch_size, self.seq_length, self.hidden_size)  )

				def 							A			(  self							:     Any							,     _lowercase							:     str							,     _lowercase							:     List[str]							,     _lowercase							:     List[Any]							,     _lowercase							:     List[Any]							,     _lowercase							:     str							,     _lowercase							:     Any							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Dict							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		TFXLMWithLMHeadModel(_lowercase  )

										UpperCAmelCase__       						=		{"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
										UpperCAmelCase__       						=		model(_lowercase  )

										UpperCAmelCase__       						=		outputs

										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.vocab_size)  )

				def 							A			(  self							:     Union[str, Any]							,     _lowercase							:     int							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Any							,     _lowercase							:     int							,     _lowercase							:     Tuple							,     _lowercase							:     List[Any]							,     _lowercase							:     str							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     List[str]							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		TFXLMForQuestionAnsweringSimple(_lowercase  )

										UpperCAmelCase__       						=		{"""input_ids""": input_ids, """lengths""": input_lengths}

										UpperCAmelCase__       						=		model(_lowercase  )

										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							:     Union[str, Any]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     List[str]							,     _lowercase							:     Any							,     _lowercase							:     int							,     _lowercase							:     List[Any]							,     _lowercase							:     Tuple							,     _lowercase							:     List[Any]							,     _lowercase							:     List[Any]							,     _lowercase							:     Dict							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		TFXLMForSequenceClassification(_lowercase  )

										UpperCAmelCase__       						=		{"""input_ids""": input_ids, """lengths""": input_lengths}

										UpperCAmelCase__       						=		model(_lowercase  )

										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.type_sequence_label_size)  )

				def 							A			(  self							:     Optional[int]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Any							,     _lowercase							:     Any							,     _lowercase							:     Optional[int]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Tuple							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     str							,     _lowercase							:     Tuple							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.num_labels
										UpperCAmelCase__       						=		TFXLMForTokenClassification(config=_lowercase  )
										UpperCAmelCase__       						=		{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
										UpperCAmelCase__       						=		model(_lowercase  )
										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.num_labels)  )

				def 							A			(  self							:     Union[str, Any]							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Any							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     List[str]							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Optional[int]							,     _lowercase							:     List[Any]							,     _lowercase							:     Any							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.num_choices
										UpperCAmelCase__       						=		TFXLMForMultipleChoice(config=_lowercase  )
										UpperCAmelCase__       						=		tf.tile(tf.expand_dims(_lowercase							,     1  )							,     (1, self.num_choices, 1)  )
										UpperCAmelCase__       						=		tf.tile(tf.expand_dims(_lowercase							,     1  )							,     (1, self.num_choices, 1)  )
										UpperCAmelCase__       						=		tf.tile(tf.expand_dims(_lowercase							,     1  )							,     (1, self.num_choices, 1)  )
										UpperCAmelCase__       						=		{
										    """input_ids""": multiple_choice_inputs_ids,
										    """attention_mask""": multiple_choice_input_mask,
										    """token_type_ids""": multiple_choice_token_type_ids,
										}
										UpperCAmelCase__       						=		model(_lowercase  )
										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.num_choices)  )

				def 							A			(  self							:     Dict  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.prepare_config_and_inputs()
										(
										    (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   (
										    UpperCAmelCase__
										)						,   
										)       						=		config_and_inputs
										UpperCAmelCase__       						=		{
										    """input_ids""": input_ids,
										    """token_type_ids""": token_type_ids,
										    """langs""": token_type_ids,
										    """lengths""": input_lengths,
										}
										return config, inputs_dict


@require_tf
class       _lowercase		( __lowerCamelCase   ,   __lowerCamelCase   ,   unittest.TestCase	):
				lowerCamelCase__							=							(
				    (
				        TFXLMModel,
				        TFXLMWithLMHeadModel,
				        TFXLMForSequenceClassification,
				        TFXLMForQuestionAnsweringSimple,
				        TFXLMForTokenClassification,
				        TFXLMForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				lowerCamelCase__							=							(
				    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				lowerCamelCase__							=							(
				    {
				        'feature-extraction': TFXLMModel,
				        'fill-mask': TFXLMWithLMHeadModel,
				        'question-answering': TFXLMForQuestionAnsweringSimple,
				        'text-classification': TFXLMForSequenceClassification,
				        'text-generation': TFXLMWithLMHeadModel,
				        'token-classification': TFXLMForTokenClassification,
				        'zero-shot': TFXLMForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				lowerCamelCase__							=							False
				lowerCamelCase__							=							False

				def 							A			(  self							:     Optional[int]							,     _lowercase							:     List[Any]							,     _lowercase							:     List[str]							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Tuple  ):


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

										return False

				def 							A			(  self							:     List[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		TFXLMModelTester(self  )
										UpperCAmelCase__       						=		ConfigTester(self							,     config_class=_lowercase							,     emb_dim=3_7  )

				def 							A			(  self							:     Any  ):


										'''simple docstring'''
										self.config_tester.run_common_tests()

				def 							A			(  self							:     Optional[int]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_model(*_lowercase  )

				def 							A			(  self							:     Optional[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_lm_head(*_lowercase  )

				def 							A			(  self							:     str  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_qa(*_lowercase  )

				def 							A			(  self							:     Optional[int]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_sequence_classif(*_lowercase  )

				def 							A			(  self							:     str  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_token_classification(*_lowercase  )

				def 							A			(  self							:     Optional[int]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_multiple_choice(*_lowercase  )

				@slow
				def 							A			(  self							:     Union[str, Any]  ):


										'''simple docstring'''
										for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																UpperCAmelCase__       						=		TFXLMModel.from_pretrained(_lowercase  )
																self.assertIsNotNone(_lowercase  )


@require_tf
class       _lowercase		( unittest.TestCase	):

				@slow
				def 							A			(  self							:     Optional[int]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048"""  )
										UpperCAmelCase__       						=		tf.convert_to_tensor([[1_4, 4_4_7]]							,     dtype=tf.intaa  )  # the president
										UpperCAmelCase__       						=		[
										    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
										UpperCAmelCase__       						=		model.generate(_lowercase							,     do_sample=_lowercase  )
										self.assertListEqual(output_ids[0].numpy().tolist()							,     _lowercase  )


"""simple docstring"""







from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
						if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.27.0""")):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ...utils.dummy_torch_and_transformers_objects import (
						    AudioLDMPipeline,
						)
else:
						from .pipeline_audioldm import AudioLDMPipeline

