






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





	"""simple docstring"""






	def __init__(							self	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      parent
							_UpperCAmelCase     =      13
							_UpperCAmelCase     =      7
							_UpperCAmelCase     =      True
							_UpperCAmelCase     =      True
							_UpperCAmelCase     =      True
							_UpperCAmelCase     =      True
							_UpperCAmelCase     =      True
							_UpperCAmelCase     =      False
							_UpperCAmelCase     =      False
							_UpperCAmelCase     =      False
							_UpperCAmelCase     =      2
							_UpperCAmelCase     =      99
							_UpperCAmelCase     =      0
							_UpperCAmelCase     =      32
							_UpperCAmelCase     =      2
							_UpperCAmelCase     =      4
							_UpperCAmelCase     =      0.1
							_UpperCAmelCase     =      0.1
							_UpperCAmelCase     =      512
							_UpperCAmelCase     =      16
							_UpperCAmelCase     =      2
							_UpperCAmelCase     =      0.02
							_UpperCAmelCase     =      3
							_UpperCAmelCase     =      4
							_UpperCAmelCase     =      'last'
							_UpperCAmelCase     =      True
							_UpperCAmelCase     =      None
							_UpperCAmelCase     =      0

	def 	UpperCamelCase   (							self   ):
							"""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 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      TFXLMModel(config=_A   )
							_UpperCAmelCase     =      {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
							_UpperCAmelCase     =      model(_A   )

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

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      TFXLMWithLMHeadModel(_A   )

							_UpperCAmelCase     =      {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
							_UpperCAmelCase     =      model(_A   )

							_UpperCAmelCase     =      outputs

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

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      TFXLMForQuestionAnsweringSimple(_A   )

							_UpperCAmelCase     =      {'input_ids': input_ids, 'lengths': input_lengths}

							_UpperCAmelCase     =      model(_A   )

							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	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      TFXLMForSequenceClassification(_A   )

							_UpperCAmelCase     =      {'input_ids': input_ids, 'lengths': input_lengths}

							_UpperCAmelCase     =      model(_A   )

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

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.num_labels
							_UpperCAmelCase     =      TFXLMForTokenClassification(config=_A   )
							_UpperCAmelCase     =      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
							_UpperCAmelCase     =      model(_A   )
							self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.seq_length, self.num_labels)   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.num_choices
							_UpperCAmelCase     =      TFXLMForMultipleChoice(config=_A   )
							_UpperCAmelCase     =      tf.tile(tf.expand_dims(_A	,   1   )	,   (1, self.num_choices, 1)   )
							_UpperCAmelCase     =      tf.tile(tf.expand_dims(_A	,   1   )	,   (1, self.num_choices, 1)   )
							_UpperCAmelCase     =      tf.tile(tf.expand_dims(_A	,   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(_A   )
							self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_choices)   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.prepare_config_and_inputs()
							(
							    _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 __lowerCamelCase			(				snake_case__					,	snake_case__					,	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	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase   ):
							"""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"""







							_UpperCAmelCase     =      TFXLMModelTester(self   )
							_UpperCAmelCase     =      ConfigTester(self	,   config_class=_A	,   emb_dim=37   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							self.config_tester.run_common_tests()

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_model(*_A   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_lm_head(*_A   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_qa(*_A   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_sequence_classif(*_A   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_for_token_classification(*_A   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_for_multiple_choice(*_A   )

	@slow
	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_UpperCAmelCase     =      TFXLMModel.from_pretrained(_A   )
													self.assertIsNotNone(_A   )





@require_tf
class __lowerCamelCase			(				unittest.TestCase):





	"""simple docstring"""






	@slow
	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'   )
							_UpperCAmelCase     =      tf.convert_to_tensor([[14, 447]]	,   dtype=tf.intaa   )  # the president
							_UpperCAmelCase     =      [
							    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
							_UpperCAmelCase     =      model.generate(_A	,   do_sample=_A   )
							self.assertListEqual(output_ids[0].numpy().tolist()	,   _A   )








import unittest

import torch

from diffusers import DDIMScheduler, TextToVideoZeroPipeline
from diffusers.utils import load_pt, require_torch_gpu, slow

from ..test_pipelines_common import assert_mean_pixel_difference





@slow
@require_torch_gpu
class __lowerCamelCase			(				unittest.TestCase):





	"""simple docstring"""






	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      'runwayml/stable-diffusion-v1-5'
							_UpperCAmelCase     =      TextToVideoZeroPipeline.from_pretrained(UpperCAmelCase	,   torch_dtype=torch.floataa   ).to('cuda'   )
							_UpperCAmelCase     =      DDIMScheduler.from_config(pipe.scheduler.config   )
							_UpperCAmelCase     =      torch.Generator(device='cuda'   ).manual_seed(0   )

							_UpperCAmelCase     =      'A bear is playing a guitar on Times Square'
							_UpperCAmelCase     =      pipe(prompt=UpperCAmelCase	,   generator=UpperCAmelCase   ).images

							_UpperCAmelCase     =      load_pt(
							    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text-to-video/A bear is playing a guitar on Times Square.pt'   )

							assert_mean_pixel_difference(UpperCAmelCase	,   UpperCAmelCase   )
