
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						:





							"""simple docstring"""







							def __init__(			self ,	lowerCAmelCase__ ,	):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				parent
										SCREAMING_SNAKE_CASE_		:    Tuple 		=				1_3
										SCREAMING_SNAKE_CASE_		:    List[Any] 		=				7
										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				True
										SCREAMING_SNAKE_CASE_		:    List[Any] 		=				True
										SCREAMING_SNAKE_CASE_		:    Any 		=				True
										SCREAMING_SNAKE_CASE_		:    List[str] 		=				True
										SCREAMING_SNAKE_CASE_		:    Dict 		=				True
										SCREAMING_SNAKE_CASE_		:    List[Any] 		=				False
										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				False
										SCREAMING_SNAKE_CASE_		:    Optional[int] 		=				False
										SCREAMING_SNAKE_CASE_		:    Optional[int] 		=				2
										SCREAMING_SNAKE_CASE_		:    Any 		=				9_9
										SCREAMING_SNAKE_CASE_		:    Optional[int] 		=				0
										SCREAMING_SNAKE_CASE_		:    str 		=				3_2
										SCREAMING_SNAKE_CASE_		:    Dict 		=				2
										SCREAMING_SNAKE_CASE_		:    Optional[int] 		=				4
										SCREAMING_SNAKE_CASE_		:    Any 		=				0.1
										SCREAMING_SNAKE_CASE_		:    List[str] 		=				0.1
										SCREAMING_SNAKE_CASE_		:    Tuple 		=				5_1_2
										SCREAMING_SNAKE_CASE_		:    Optional[Any] 		=				1_6
										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				2
										SCREAMING_SNAKE_CASE_		:    Dict 		=				0.02
										SCREAMING_SNAKE_CASE_		:    Any 		=				3
										SCREAMING_SNAKE_CASE_		:    List[Any] 		=				4
										SCREAMING_SNAKE_CASE_		:    str 		=				'''last'''
										SCREAMING_SNAKE_CASE_		:    Optional[Any] 		=				True
										SCREAMING_SNAKE_CASE_		:    List[str] 		=				None
										SCREAMING_SNAKE_CASE_		:    int 		=				0






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Optional[Any] 		=				ids_tensor([self.batch_size, self.seq_length] ,	self.vocab_size					)
										SCREAMING_SNAKE_CASE_		:    Optional[int] 		=				random_attention_mask([self.batch_size, self.seq_length] ,	dtype=tf.floataa					)

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

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

										SCREAMING_SNAKE_CASE_		:    Tuple 		=				None
										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				None
										SCREAMING_SNAKE_CASE_		:    str 		=				None
										if self.use_labels:
													SCREAMING_SNAKE_CASE_		:    List[Any] 		=				ids_tensor([self.batch_size] ,	self.type_sequence_label_size					)
													SCREAMING_SNAKE_CASE_		:    Optional[Any] 		=				ids_tensor([self.batch_size, self.seq_length] ,	self.num_labels					)
													SCREAMING_SNAKE_CASE_		:    List[Any] 		=				ids_tensor([self.batch_size] ,	2 ,	dtype=tf.floataa					)
													SCREAMING_SNAKE_CASE_		:    int 		=				ids_tensor([self.batch_size] ,	self.num_choices					)

										SCREAMING_SNAKE_CASE_		:    int 		=				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 				UpperCamelCase__    (			self ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Any 		=				TFXLMModel(config=lowerCAmelCase__					)
										SCREAMING_SNAKE_CASE_		:    List[Any] 		=				{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
										SCREAMING_SNAKE_CASE_		:    List[str] 		=				model(lowerCAmelCase__					)

										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				[input_ids, input_mask]
										SCREAMING_SNAKE_CASE_		:    str 		=				model(lowerCAmelCase__					)
										self.parent.assertEqual(result.last_hidden_state.shape ,	(self.batch_size, self.seq_length, self.hidden_size)					)






							def 				UpperCamelCase__    (			self ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    int 		=				TFXLMWithLMHeadModel(lowerCAmelCase__					)

										SCREAMING_SNAKE_CASE_		:    Any 		=				{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
										SCREAMING_SNAKE_CASE_		:    Tuple 		=				model(lowerCAmelCase__					)

										SCREAMING_SNAKE_CASE_		:    Optional[int] 		=				outputs

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






							def 				UpperCamelCase__    (			self ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Optional[Any] 		=				TFXLMForQuestionAnsweringSimple(lowerCAmelCase__					)

										SCREAMING_SNAKE_CASE_		:    Optional[Any] 		=				{'''input_ids''': input_ids, '''lengths''': input_lengths}

										SCREAMING_SNAKE_CASE_		:    Optional[int] 		=				model(lowerCAmelCase__					)

										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 				UpperCamelCase__    (			self ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Dict 		=				TFXLMForSequenceClassification(lowerCAmelCase__					)

										SCREAMING_SNAKE_CASE_		:    Tuple 		=				{'''input_ids''': input_ids, '''lengths''': input_lengths}

										SCREAMING_SNAKE_CASE_		:    str 		=				model(lowerCAmelCase__					)

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






							def 				UpperCamelCase__    (			self ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Tuple 		=				self.num_labels
										SCREAMING_SNAKE_CASE_		:    Optional[Any] 		=				TFXLMForTokenClassification(config=lowerCAmelCase__					)
										SCREAMING_SNAKE_CASE_		:    Optional[Any] 		=				{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
										SCREAMING_SNAKE_CASE_		:    Any 		=				model(lowerCAmelCase__					)
										self.parent.assertEqual(result.logits.shape ,	(self.batch_size, self.seq_length, self.num_labels)					)






							def 				UpperCamelCase__    (			self ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    List[Any] 		=				self.num_choices
										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				TFXLMForMultipleChoice(config=lowerCAmelCase__					)
										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				tf.tile(tf.expand_dims(lowerCAmelCase__ ,	1					) ,	(1, self.num_choices, 1)					)
										SCREAMING_SNAKE_CASE_		:    Tuple 		=				tf.tile(tf.expand_dims(lowerCAmelCase__ ,	1					) ,	(1, self.num_choices, 1)					)
										SCREAMING_SNAKE_CASE_		:    List[Any] 		=				tf.tile(tf.expand_dims(lowerCAmelCase__ ,	1					) ,	(1, self.num_choices, 1)					)
										SCREAMING_SNAKE_CASE_		:    Tuple 		=				{
										    '''input_ids''': multiple_choice_inputs_ids,
										    '''attention_mask''': multiple_choice_input_mask,
										    '''token_type_ids''': multiple_choice_token_type_ids,
										}
										SCREAMING_SNAKE_CASE_		:    Dict 		=				model(lowerCAmelCase__					)
										self.parent.assertEqual(result.logits.shape ,	(self.batch_size, self.num_choices)					)






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				self.prepare_config_and_inputs()
										(
										    SCREAMING_SNAKE_CASE_	
										)		:    Dict 		=				config_and_inputs
										SCREAMING_SNAKE_CASE_		:    int 		=				{
										    '''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						(A_  ,					A_  ,					unittest.TestCase     ):





							"""simple docstring"""







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






							def 				UpperCamelCase__    (			self ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__ ,	lowerCAmelCase__					):





										"""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 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    List[Any] 		=				TFXLMModelTester(self					)
										SCREAMING_SNAKE_CASE_		:    Dict 		=				ConfigTester(self ,	config_class=lowerCAmelCase__ ,	emb_dim=3_7					)






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										self.config_tester.run_common_tests()






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    str 		=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_model(*lowerCAmelCase__					)






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Tuple 		=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_lm_head(*lowerCAmelCase__					)






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Tuple 		=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_qa(*lowerCAmelCase__					)






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Any 		=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_sequence_classif(*lowerCAmelCase__					)






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    List[str] 		=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_token_classification(*lowerCAmelCase__					)






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    str 		=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCAmelCase__					)






							@slow
							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													SCREAMING_SNAKE_CASE_		:    Optional[Any] 		=				TFXLMModel.from_pretrained(lowerCAmelCase__					)
													self.assertIsNotNone(lowerCAmelCase__					)







@require_tf
class   __lowercase						(unittest.TestCase     ):





							"""simple docstring"""







							@slow
							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Dict 		=				TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'					)
										SCREAMING_SNAKE_CASE_		:    List[str] 		=				tf.convert_to_tensor([[1_4, 4_4_7]] ,	dtype=tf.intaa					)  # the president
										SCREAMING_SNAKE_CASE_		:    Optional[int] 		=				[
										    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
										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				model.generate(lowerCAmelCase__ ,	do_sample=lowerCAmelCase__					)
										self.assertListEqual(output_ids[0].numpy().tolist() ,	lowerCAmelCase__					)









import unittest
from dataclasses import dataclass
from typing import List, Union

import numpy as np
import PIL.Image

from diffusers.utils.outputs import BaseOutput







@dataclass
class   __lowercase						(__SCREAMING_SNAKE_CASE     ):





							"""simple docstring"""







							_UpperCAmelCase						     =	42







class   __lowercase						(unittest.TestCase     ):





							"""simple docstring"""







							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				CustomOutput(images=np.random.rand(1 ,	3 ,	4 ,	4					)					)

										# check every way of getting the attribute
										assert isinstance(outputs.images ,	np.ndarray					)
										assert outputs.images.shape == (1, 3, 4, 4)
										assert isinstance(outputs['images'] ,	np.ndarray					)
										assert outputs["images"].shape == (1, 3, 4, 4)
										assert isinstance(outputs[0] ,	np.ndarray					)
										assert outputs[0].shape == (1, 3, 4, 4)

										# test with a non-tensor attribute
										SCREAMING_SNAKE_CASE_		:    Tuple 		=				CustomOutput(images=[PIL.Image.new('RGB' ,	(4, 4)					)]					)

										# check every way of getting the attribute
										assert isinstance(outputs.images ,	lowerCAmelCase__					)
										assert isinstance(outputs.images[0] ,	PIL.Image.Image					)
										assert isinstance(outputs['images'] ,	lowerCAmelCase__					)
										assert isinstance(outputs['images'][0] ,	PIL.Image.Image					)
										assert isinstance(outputs[0] ,	lowerCAmelCase__					)
										assert isinstance(outputs[0][0] ,	PIL.Image.Image					)






							def 				UpperCamelCase__    (			self					):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:    Union[str, Any] 		=				CustomOutput({'images': np.random.rand(1 ,	3 ,	4 ,	4					)}					)

										# check every way of getting the attribute
										assert isinstance(outputs.images ,	np.ndarray					)
										assert outputs.images.shape == (1, 3, 4, 4)
										assert isinstance(outputs['images'] ,	np.ndarray					)
										assert outputs["images"].shape == (1, 3, 4, 4)
										assert isinstance(outputs[0] ,	np.ndarray					)
										assert outputs[0].shape == (1, 3, 4, 4)

										# test with a non-tensor attribute
										SCREAMING_SNAKE_CASE_		:    Any 		=				CustomOutput({'images': [PIL.Image.new('RGB' ,	(4, 4)					)]}					)

										# check every way of getting the attribute
										assert isinstance(outputs.images ,	lowerCAmelCase__					)
										assert isinstance(outputs.images[0] ,	PIL.Image.Image					)
										assert isinstance(outputs['images'] ,	lowerCAmelCase__					)
										assert isinstance(outputs['images'][0] ,	PIL.Image.Image					)
										assert isinstance(outputs[0] ,	lowerCAmelCase__					)
										assert isinstance(outputs[0][0] ,	PIL.Image.Image					)





