
import unittest

from transformers import 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
	    OpenAIGPTConfig,
	    OpenAIGPTDoubleHeadsModel,
	    OpenAIGPTForSequenceClassification,
	    OpenAIGPTLMHeadModel,
	    OpenAIGPTModel,
	)







class 			A_  :




	'''simple docstring'''


	def __init__(			self						,       snake_case						,       snake_case=13						,       snake_case=7						,       snake_case=True						,       snake_case=True						,       snake_case=True						,       snake_case=99						,       snake_case=32						,       snake_case=5						,       snake_case=4						,       snake_case=37						,       snake_case="gelu"						,       snake_case=0.1						,       snake_case=0.1						,       snake_case=512						,       snake_case=16						,       snake_case=2						,       snake_case=0.02						,       snake_case=3						,       snake_case=4						,       snake_case=None						,       ):
		lowercase	    =       parent
		lowercase	    =       batch_size
		lowercase	    =       seq_length
		lowercase	    =       is_training
		lowercase	    =       use_token_type_ids
		lowercase	    =       use_labels
		lowercase	    =       vocab_size
		lowercase	    =       hidden_size
		lowercase	    =       num_hidden_layers
		lowercase	    =       num_attention_heads
		lowercase	    =       intermediate_size
		lowercase	    =       hidden_act
		lowercase	    =       hidden_dropout_prob
		lowercase	    =       attention_probs_dropout_prob
		lowercase	    =       max_position_embeddings
		lowercase	    =       type_vocab_size
		lowercase	    =       type_sequence_label_size
		lowercase	    =       initializer_range
		lowercase	    =       num_labels
		lowercase	    =       num_choices
		lowercase	    =       scope
		lowercase	    =       self.vocab_size - 1





	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       ids_tensor([self.batch_size, self.seq_length]						,       self.vocab_size			)

		lowercase	    =       None
		if self.use_token_type_ids:
			lowercase	    =       ids_tensor([self.batch_size, self.seq_length]						,       self.type_vocab_size			)

		lowercase	    =       None
		lowercase	    =       None
		lowercase	    =       None
		if self.use_labels:
			lowercase	    =       ids_tensor([self.batch_size]						,       self.type_sequence_label_size			)
			lowercase	    =       ids_tensor([self.batch_size, self.seq_length]						,       self.num_labels			)
			lowercase	    =       ids_tensor([self.batch_size]						,       self.num_choices			)

		lowercase	    =       OpenAIGPTConfig(
		    vocab_size=self.vocab_size						,       n_embd=self.hidden_size						,       n_layer=self.num_hidden_layers						,       n_head=self.num_attention_heads						,       n_positions=self.max_position_embeddings						,       pad_token_id=self.pad_token_id						,       )

		lowercase	    =       ids_tensor([self.num_hidden_layers, self.num_attention_heads]						,       2			)

		return (
		    config,
		    input_ids,
		    head_mask,
		    token_type_ids,
		    sequence_labels,
		    token_labels,
		    choice_labels,
		)





	def       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case						,       snake_case						,       *snake_case			):
		lowercase	    =       OpenAIGPTModel(config=snake_case			)
		model.to(snake_case			)
		model.eval()

		lowercase	    =       model(snake_case						,       token_type_ids=snake_case						,       head_mask=snake_case			)
		lowercase	    =       model(snake_case						,       token_type_ids=snake_case			)
		lowercase	    =       model(snake_case			)

		self.parent.assertEqual(result.last_hidden_state.shape						,       (self.batch_size, self.seq_length, self.hidden_size)			)





	def       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case						,       snake_case						,       *snake_case			):
		lowercase	    =       OpenAIGPTLMHeadModel(snake_case			)
		model.to(snake_case			)
		model.eval()

		lowercase	    =       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       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case						,       snake_case						,       *snake_case			):
		lowercase	    =       OpenAIGPTDoubleHeadsModel(snake_case			)
		model.to(snake_case			)
		model.eval()

		lowercase	    =       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       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case						,       snake_case						,       *snake_case			):
		lowercase	    =       self.num_labels
		lowercase	    =       OpenAIGPTForSequenceClassification(snake_case			)
		model.to(snake_case			)
		model.eval()

		lowercase	    =       ids_tensor([self.batch_size]						,       self.type_sequence_label_size			)
		lowercase	    =       model(snake_case						,       token_type_ids=snake_case						,       labels=snake_case			)
		self.parent.assertEqual(result.logits.shape						,       (self.batch_size, self.num_labels)			)





	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       self.prepare_config_and_inputs()
		(
		    (
		    lowercase
		)    ,   (
		    lowercase
		)    ,   (
		    lowercase
		)    ,   (
		    lowercase
		)    ,   (
		    lowercase
		)    ,   (
		    lowercase
		)    ,   (
		    lowercase
		)    ,   
		)	    =       config_and_inputs
		lowercase	    =       {
		    'input_ids': input_ids,
		    'token_type_ids': token_type_ids,
		    'head_mask': head_mask,
		}

		return config, inputs_dict







@require_torch
class 			A_  (     __lowerCamelCase ,      __lowerCamelCase ,      __lowerCamelCase ,      unittest.TestCase  ):




	'''simple docstring'''


	_UpperCamelCase	:	Optional[Any]									=			(
	    (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
	    if is_torch_available()
	    else ()
	)
	_UpperCamelCase	:	Tuple									=			(
	    (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
	)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
	_UpperCamelCase	:	str									=			(
	    {
	        """feature-extraction""": OpenAIGPTModel,
	        """text-classification""": OpenAIGPTForSequenceClassification,
	        """text-generation""": OpenAIGPTLMHeadModel,
	        """zero-shot""": OpenAIGPTForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)





	def       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case						,       snake_case						,       snake_case			):
		if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
			# Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
			# `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
			# tiny config could not be created.
			return True

		return False





	def       SCREAMING_SNAKE_CASE__		(			self						,       snake_case						,       snake_case						,       snake_case=False			):
		lowercase	    =       super()._prepare_for_class(snake_case						,       snake_case						,       return_labels=snake_case			)

		if return_labels:
			if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
				lowercase	    =       torch.zeros(
				    (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)						,       dtype=torch.long						,       device=snake_case						,       )
				lowercase	    =       inputs_dict['labels']
				lowercase	    =       inputs_dict['labels']
				lowercase	    =       torch.zeros(
				    (self.model_tester.batch_size, self.model_tester.num_choices)						,       dtype=torch.long						,       device=snake_case						,       )
				lowercase	    =       torch.zeros(
				    self.model_tester.batch_size						,       dtype=torch.long						,       device=snake_case			)
		return inputs_dict





	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       OpenAIGPTModelTester(self			)
		lowercase	    =       ConfigTester(self						,       config_class=snake_case						,       n_embd=37			)





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





	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_openai_gpt_model(*snake_case			)





	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_lm_head_model(*snake_case			)





	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_double_lm_head_model(*snake_case			)





	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*snake_case			)





	@slow
	def       SCREAMING_SNAKE_CASE__		(			self			):
		for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			lowercase	    =       OpenAIGPTModel.from_pretrained(snake_case			)
			self.assertIsNotNone(snake_case			)







@require_torch
class 			A_  (     unittest.TestCase  ):




	'''simple docstring'''


	@slow
	def       SCREAMING_SNAKE_CASE__		(			self			):
		lowercase	    =       OpenAIGPTLMHeadModel.from_pretrained('openai-gpt'			)
		model.to(snake_case			)
		lowercase	    =       torch.tensor([[481, 4735, 544]]						,       dtype=torch.long						,       device=snake_case			)  # the president is
		lowercase	    =       [
		    481,
		    4735,
		    544,
		    246,
		    963,
		    870,
		    762,
		    239,
		    244,
		    4_0477,
		    244,
		    249,
		    719,
		    881,
		    487,
		    544,
		    240,
		    244,
		    603,
		    481,
		]  # the president is a very good man. " \n " i\'m sure he is, " said the

		lowercase	    =       model.generate(snake_case						,       do_sample=snake_case			)
		self.assertListEqual(output_ids[0].tolist()						,       snake_case			)





"""simple docstring"""

import unittest

from transformers import BarthezTokenizer, BarthezTokenizerFast, BatchEncoding
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow

from ...test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
@require_sentencepiece
@slow  # see https://github.com/huggingface/transformers/issues/11457
class  lowerCamelCase__    (		_a      , unittest.TestCase     ):
      a			:  Union[str, Any]           =		BarthezTokenizer
      a			:  Any           =		BarthezTokenizerFast
      a			:  Tuple           =		True
      a			:  List[Any]           =		True
      def SCREAMING_SNAKE_CASE_						(		self						:						List[str]				):






       '''simple docstring'''


       super().setUp()

       __lowercase						=						BarthezTokenizerFast.from_pretrained("""moussaKam/mbarthez"""				)
       tokenizer.save_pretrained(self.tmpdirname				)
       tokenizer.save_pretrained(self.tmpdirname   ,							legacy_format=A_				)
       __lowercase						=						tokenizer
      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple				):






       '''simple docstring'''


       __lowercase						=						"""<pad>"""
       __lowercase						=						1

       self.assertEqual(self.get_tokenizer()._convert_token_to_id(A_				)   ,							A_				)
       self.assertEqual(self.get_tokenizer()._convert_id_to_token(A_				)   ,							A_				)
      def SCREAMING_SNAKE_CASE_						(		self						:						List[str]				):






       '''simple docstring'''


       __lowercase						=						list(self.get_tokenizer().get_vocab().keys()				)

       self.assertEqual(vocab_keys[0]   ,							"""<s>"""				)
       self.assertEqual(vocab_keys[1]   ,							"""<pad>"""				)
       self.assertEqual(vocab_keys[-1]   ,							"""<mask>"""				)
       self.assertEqual(len(A_				)   ,							1_0_1_1_2_2				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Union[str, Any]				):






       '''simple docstring'''


       self.assertEqual(self.get_tokenizer().vocab_size   ,							1_0_1_1_2_2				)
      @require_torch
      def SCREAMING_SNAKE_CASE_						(		self						:						str				):






       '''simple docstring'''


       __lowercase						=						["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
       __lowercase						=						[0, 5_7, 3_0_1_8, 7_0_3_0_7, 9_1, 2]

       __lowercase						=						self.tokenizer(
           A_   ,							max_length=len(A_				)   ,							padding=A_   ,							truncation=A_   ,							return_tensors="""pt"""				)
       self.assertIsInstance(A_   ,							A_				)

       self.assertEqual((2, 6)   ,							batch.input_ids.shape				)
       self.assertEqual((2, 6)   ,							batch.attention_mask.shape				)
       __lowercase						=						batch.input_ids.tolist()[0]
       self.assertListEqual(A_   ,							A_				)
      def SCREAMING_SNAKE_CASE_						(		self						:						int				):






       '''simple docstring'''


       if not self.test_rust_tokenizer:
        return

       __lowercase						=						self.get_tokenizer()
       __lowercase						=						self.get_rust_tokenizer()

       __lowercase						=						"""I was born in 92000, and this is falsé."""

       __lowercase						=						tokenizer.tokenize(A_				)
       __lowercase						=						rust_tokenizer.tokenize(A_				)
       self.assertListEqual(A_   ,							A_				)

       __lowercase						=						tokenizer.encode(A_   ,							add_special_tokens=A_				)
       __lowercase						=						rust_tokenizer.encode(A_   ,							add_special_tokens=A_				)
       self.assertListEqual(A_   ,							A_				)

       __lowercase						=						self.get_rust_tokenizer()
       __lowercase						=						tokenizer.encode(A_				)
       __lowercase						=						rust_tokenizer.encode(A_				)
       self.assertListEqual(A_   ,							A_				)






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






       '''simple docstring'''


       __lowercase						=						{"""input_ids""": [[0, 4_9_0, 1_4_3_2_8, 4_5_0_7, 3_5_4, 4_7, 4_3_6_6_9, 9_5, 2_5, 7_8_1_1_7, 2_0_2_1_5, 1_9_7_7_9, 1_9_0, 2_2, 4_0_0, 4, 3_5_3_4_3, 8_0_3_1_0, 6_0_3, 8_6, 2_4_9_3_7, 1_0_5, 3_3_4_3_8, 9_4_7_6_2, 1_9_6, 3_9_6_4_2, 7, 1_5, 1_5_9_3_3, 1_7_3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 1_0_5_3_4, 8_7, 2_5, 6_6, 3_3_5_8, 1_9_6, 5_5_2_8_9, 8, 8_2_9_6_1, 8_1, 2_2_0_4, 7_5_2_0_3, 7, 1_5, 7_6_3, 1_2_9_5_6, 2_1_6, 1_7_8, 1_4_3_2_8, 9_5_9_5, 1_3_7_7, 6_9_6_9_3, 7, 4_4_8, 7_1_0_2_1, 1_9_6, 1_8_1_0_6, 1_4_3_7, 1_3_9_7_4, 1_0_8, 9_0_8_3, 4, 4_9_3_1_5, 7, 3_9, 8_6, 1_3_2_6, 2_7_9_3, 4_6_3_3_3, 4, 4_4_8, 1_9_6, 7_4_5_8_8, 7, 4_9_3_1_5, 7, 3_9, 2_1, 8_2_2, 3_8_4_7_0, 7_4, 2_1, 6_6_7_2_3, 6_2_4_8_0, 8, 2_2_0_5_0, 5, 2]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
       # fmt: on

       # moussaKam/mbarthez is a french model. So we also use french texts.
       __lowercase						=						[
           """Le transformeur est un modèle d'apprentissage profond introduit en 2017, """
           """utilisé principalement dans le domaine du traitement automatique des langues (TAL).""",
           """À l'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus """
           """pour gérer des données séquentielles, telles que le langage naturel, pour des tâches """
           """telles que la traduction et la synthèse de texte.""",
       ]

       self.tokenizer_integration_test_util(
           expected_encoding=A_   ,							model_name="""moussaKam/mbarthez"""   ,							revision="""c2e4ecbca5e3cd2c37fe1ac285ca4fbdf1366fb6"""   ,							sequences=A_   ,							)
