





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


				def __init__(		self ,			UpperCAmelCase_ ,			):
								lowerCamelCase									=parent
								lowerCamelCase									=13
								lowerCamelCase									=7
								lowerCamelCase									=True
								lowerCamelCase									=True
								lowerCamelCase									=True
								lowerCamelCase									=True
								lowerCamelCase									=True
								lowerCamelCase									=False
								lowerCamelCase									=False
								lowerCamelCase									=False
								lowerCamelCase									=2
								lowerCamelCase									=99
								lowerCamelCase									=0
								lowerCamelCase									=32
								lowerCamelCase									=2
								lowerCamelCase									=4
								lowerCamelCase									=0.1
								lowerCamelCase									=0.1
								lowerCamelCase									=512
								lowerCamelCase									=16
								lowerCamelCase									=2
								lowerCamelCase									=0.0_2
								lowerCamelCase									=3
								lowerCamelCase									=4
								lowerCamelCase									="""last"""
								lowerCamelCase									=True
								lowerCamelCase									=None
								lowerCamelCase									=0


				def _snake_case							(		self				):
								lowerCamelCase									=ids_tensor([self.batch_size, self.seq_length] ,			self.vocab_size				)
								lowerCamelCase									=random_attention_mask([self.batch_size, self.seq_length] ,			dtype=tf.floataa				)

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

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

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

								lowerCamelCase									=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 _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			):
								lowerCamelCase									=TFXLMModel(config=UpperCAmelCase_				)
								lowerCamelCase									={"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
								lowerCamelCase									=model(UpperCAmelCase_				)

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


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			):
								lowerCamelCase									=TFXLMWithLMHeadModel(UpperCAmelCase_				)

								lowerCamelCase									={"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
								lowerCamelCase									=model(UpperCAmelCase_				)

								lowerCamelCase									=outputs

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


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			):
								lowerCamelCase									=TFXLMForQuestionAnsweringSimple(UpperCAmelCase_				)

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

								lowerCamelCase									=model(UpperCAmelCase_				)

								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 _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			):
								lowerCamelCase									=TFXLMForSequenceClassification(UpperCAmelCase_				)

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

								lowerCamelCase									=model(UpperCAmelCase_				)

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


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			):
								lowerCamelCase									=self.num_labels
								lowerCamelCase									=TFXLMForTokenClassification(config=UpperCAmelCase_				)
								lowerCamelCase									={"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
								lowerCamelCase									=model(UpperCAmelCase_				)
								self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.seq_length, self.num_labels)				)


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			):
								lowerCamelCase									=self.num_choices
								lowerCamelCase									=TFXLMForMultipleChoice(config=UpperCAmelCase_				)
								lowerCamelCase									=tf.tile(tf.expand_dims(UpperCAmelCase_ ,			1				) ,			(1, self.num_choices, 1)				)
								lowerCamelCase									=tf.tile(tf.expand_dims(UpperCAmelCase_ ,			1				) ,			(1, self.num_choices, 1)				)
								lowerCamelCase									=tf.tile(tf.expand_dims(UpperCAmelCase_ ,			1				) ,			(1, self.num_choices, 1)				)
								lowerCamelCase									={
								    """input_ids""": multiple_choice_inputs_ids,
								    """attention_mask""": multiple_choice_input_mask,
								    """token_type_ids""": multiple_choice_token_type_ids,
								}
								lowerCamelCase									=model(UpperCAmelCase_				)
								self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.num_choices)				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.prepare_config_and_inputs()
								(
								    (
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	(
								    lowerCamelCase
								)			,	
								)									=config_and_inputs
								lowerCamelCase									={
								    """input_ids""": input_ids,
								    """token_type_ids""": token_type_ids,
								    """langs""": token_type_ids,
								    """lengths""": input_lengths,
								}
								return config, inputs_dict




@require_tf
class    __A  (    a     ,       a     ,       unittest.TestCase     ):
				__A  =					(
				    (
				        TFXLMModel,
				        TFXLMWithLMHeadModel,
				        TFXLMForSequenceClassification,
				        TFXLMForQuestionAnsweringSimple,
				        TFXLMForTokenClassification,
				        TFXLMForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				__A  =					(
				    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				__A  =					(
				    {
				        """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 {}
				)
				__A  =					False
				__A  =					False


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_ ,			UpperCAmelCase_				):
								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 _snake_case							(		self				):
								lowerCamelCase									=TFXLMModelTester(self				)
								lowerCamelCase									=ConfigTester(self ,			config_class=UpperCAmelCase_ ,			emb_dim=37				)


				def _snake_case							(		self				):
								self.config_tester.run_common_tests()


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_model(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_lm_head(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_qa(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_sequence_classif(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_for_token_classification(*UpperCAmelCase_				)


				def _snake_case							(		self				):
								lowerCamelCase									=self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCAmelCase_				)


				@slow
				def _snake_case							(		self				):
								for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowerCamelCase									=TFXLMModel.from_pretrained(UpperCAmelCase_				)
												self.assertIsNotNone(UpperCAmelCase_				)




@require_tf
class    __A  (    unittest.TestCase     ):


				@slow
				def _snake_case							(		self				):
								lowerCamelCase									=TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048"""				)
								lowerCamelCase									=tf.convert_to_tensor([[14, 447]] ,			dtype=tf.intaa				)  # the president
								lowerCamelCase									=[
								    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									=model.generate(UpperCAmelCase_ ,			do_sample=UpperCAmelCase_				)
								self.assertListEqual(output_ids[0].numpy().tolist() ,			UpperCAmelCase_				)












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCAmelCase__    :      Optional[Any]       					={
    '''configuration_donut_swin''': ['''DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DonutSwinConfig'''],
    '''processing_donut''': ['''DonutProcessor'''],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__    :      Any       					=[
							    '''DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''DonutSwinModel''',
							    '''DonutSwinPreTrainedModel''',
							]

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__    :      Tuple       					=['''DonutFeatureExtractor''']
							UpperCAmelCase__    :      List[str]       					=['''DonutImageProcessor''']


if TYPE_CHECKING:
							from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
							from .processing_donut import DonutProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_donut_swin import (
														    DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
														    DonutSwinModel,
														    DonutSwinPreTrainedModel,
														)

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_donut import DonutFeatureExtractor
														from .image_processing_donut import DonutImageProcessor

else:
							import sys

							UpperCAmelCase__    :      int       					=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





