

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






  """simple docstring"""


  def __init__(							self						:		Any     ,       __lowerCamelCase						:		List[Any]     ,       __lowerCamelCase						:		Optional[Any]=13     ,       __lowerCamelCase						:		Union[str, Any]=7     ,       __lowerCamelCase						:		Tuple=True     ,       __lowerCamelCase						:		Union[str, Any]=True     ,       __lowerCamelCase						:		int=True     ,       __lowerCamelCase						:		Any=99     ,       __lowerCamelCase						:		Any=32     ,       __lowerCamelCase						:		Union[str, Any]=5     ,       __lowerCamelCase						:		str=4     ,       __lowerCamelCase						:		Tuple=37     ,       __lowerCamelCase						:		str="gelu"     ,       __lowerCamelCase						:		Any=0.1     ,       __lowerCamelCase						:		Union[str, Any]=0.1     ,       __lowerCamelCase						:		List[str]=512     ,       __lowerCamelCase						:		Any=16     ,       __lowerCamelCase						:		Tuple=2     ,       __lowerCamelCase						:		Tuple=0.02     ,       __lowerCamelCase						:		Dict=3     ,       __lowerCamelCase						:		Optional[int]=4     ,       __lowerCamelCase						:		Dict=None     ,       )		->							Dict:
       SCREAMING_SNAKE_CASE__   =   parent
       SCREAMING_SNAKE_CASE__   =   batch_size
       SCREAMING_SNAKE_CASE__   =   seq_length
       SCREAMING_SNAKE_CASE__   =   is_training
       SCREAMING_SNAKE_CASE__   =   use_token_type_ids
       SCREAMING_SNAKE_CASE__   =   use_labels
       SCREAMING_SNAKE_CASE__   =   vocab_size
       SCREAMING_SNAKE_CASE__   =   hidden_size
       SCREAMING_SNAKE_CASE__   =   num_hidden_layers
       SCREAMING_SNAKE_CASE__   =   num_attention_heads
       SCREAMING_SNAKE_CASE__   =   intermediate_size
       SCREAMING_SNAKE_CASE__   =   hidden_act
       SCREAMING_SNAKE_CASE__   =   hidden_dropout_prob
       SCREAMING_SNAKE_CASE__   =   attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE__   =   max_position_embeddings
       SCREAMING_SNAKE_CASE__   =   type_vocab_size
       SCREAMING_SNAKE_CASE__   =   type_sequence_label_size
       SCREAMING_SNAKE_CASE__   =   initializer_range
       SCREAMING_SNAKE_CASE__   =   num_labels
       SCREAMING_SNAKE_CASE__   =   num_choices
       SCREAMING_SNAKE_CASE__   =   scope
       SCREAMING_SNAKE_CASE__   =   self.vocab_size - 1






  def 				lowercase_		(							self						:		Optional[Any] )		->							List[Any]:
       SCREAMING_SNAKE_CASE__   =   ids_tensor([self.batch_size, self.seq_length]     ,       self.vocab_size )

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

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

       SCREAMING_SNAKE_CASE__   =   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     ,       )

       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		Optional[Any]     ,       __lowerCamelCase						:		int     ,       __lowerCamelCase						:		Optional[Any]     ,       __lowerCamelCase						:		Optional[Any]     ,       __lowerCamelCase						:		Tuple     ,       *__lowerCamelCase						:		List[str] )		->							List[Any]:
       SCREAMING_SNAKE_CASE__   =   OpenAIGPTModel(config=__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()

       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       token_type_ids=__lowerCamelCase     ,       head_mask=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       token_type_ids=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase )

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






  def 				lowercase_		(							self						:		Any     ,       __lowerCamelCase						:		Tuple     ,       __lowerCamelCase						:		Union[str, Any]     ,       __lowerCamelCase						:		List[str]     ,       __lowerCamelCase						:		Tuple     ,       *__lowerCamelCase						:		List[Any] )		->							Any:
       SCREAMING_SNAKE_CASE__   =   OpenAIGPTLMHeadModel(__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()

       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       token_type_ids=__lowerCamelCase     ,       labels=__lowerCamelCase )
       self.parent.assertEqual(result.loss.shape     ,       () )
       self.parent.assertEqual(result.logits.shape     ,       (self.batch_size, self.seq_length, self.vocab_size) )






  def 				lowercase_		(							self						:		Optional[int]     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		str     ,       *__lowerCamelCase						:		Tuple )		->							int:
       SCREAMING_SNAKE_CASE__   =   OpenAIGPTDoubleHeadsModel(__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()

       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       token_type_ids=__lowerCamelCase     ,       labels=__lowerCamelCase )
       self.parent.assertEqual(result.loss.shape     ,       () )
       self.parent.assertEqual(result.logits.shape     ,       (self.batch_size, self.seq_length, self.vocab_size) )






  def 				lowercase_		(							self						:		str     ,       __lowerCamelCase						:		Optional[Any]     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		Optional[Any]     ,       *__lowerCamelCase						:		str )		->							str:
       SCREAMING_SNAKE_CASE__   =   self.num_labels
       SCREAMING_SNAKE_CASE__   =   OpenAIGPTForSequenceClassification(__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()

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







  def 				lowercase_		(							self						:		Union[str, Any] )		->							Dict:
       SCREAMING_SNAKE_CASE__   =   self.prepare_config_and_inputs()
       (
           (
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),(
           SCREAMING_SNAKE_CASE__
       ),
       )   =   config_and_inputs
       SCREAMING_SNAKE_CASE__   =   {
           '''input_ids''': input_ids,
           '''token_type_ids''': token_type_ids,
           '''head_mask''': head_mask,
       }

       return config, inputs_dict






@require_torch
class 	UpperCAmelCase__		(	A__						,					A__						,					A__						,					unittest.TestCase	):






  """simple docstring"""


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






  def 				lowercase_		(							self						:		Union[str, Any]     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		int     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		Optional[Any]     ,       __lowerCamelCase						:		List[Any] )		->							int:
       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 				lowercase_		(							self						:		Optional[int]     ,       __lowerCamelCase						:		Union[str, Any]     ,       __lowerCamelCase						:		Optional[Any]     ,       __lowerCamelCase						:		Tuple=False )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__   =   super()._prepare_for_class(__lowerCamelCase     ,       __lowerCamelCase     ,       return_labels=__lowerCamelCase )

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






  def 				lowercase_		(							self						:		List[Any] )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   OpenAIGPTModelTester(self )
       SCREAMING_SNAKE_CASE__   =   ConfigTester(self     ,       config_class=__lowerCamelCase     ,       n_embd=37 )






  def 				lowercase_		(							self						:		int )		->							str:
       self.config_tester.run_common_tests()






  def 				lowercase_		(							self						:		Dict )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_model(*__lowerCamelCase )






  def 				lowercase_		(							self						:		Tuple )		->							Optional[int]:
       SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_lm_head_model(*__lowerCamelCase )






  def 				lowercase_		(							self						:		Any )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_double_lm_head_model(*__lowerCamelCase )






  def 				lowercase_		(							self						:		List[Any] )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*__lowerCamelCase )







  @slow
  def 				lowercase_		(							self						:		Dict )		->							Union[str, Any]:
       for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            SCREAMING_SNAKE_CASE__   =   OpenAIGPTModel.from_pretrained(__lowerCamelCase )
            self.assertIsNotNone(__lowerCamelCase )






@require_torch
class 	UpperCAmelCase__		(	unittest.TestCase	):






  """simple docstring"""


  @slow
  def 				lowercase_		(							self						:		str )		->							str:
       SCREAMING_SNAKE_CASE__   =   OpenAIGPTLMHeadModel.from_pretrained('''openai-gpt''' )
       model.to(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   torch.tensor([[481, 4735, 544]]     ,       dtype=torch.long     ,       device=__lowerCamelCase )  # the president is
       SCREAMING_SNAKE_CASE__   =   [
           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

       SCREAMING_SNAKE_CASE__   =   model.generate(__lowerCamelCase     ,       do_sample=__lowerCamelCase )
       self.assertListEqual(output_ids[0].tolist()     ,       __lowerCamelCase )





def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     if not isinstance(_A				,		_A    ):
          raise ValueError('''multiplicative_persistence() only accepts integral values'''    )
     if num < 0:
          raise ValueError('''multiplicative_persistence() does not accept negative values'''    )

     SCREAMING_SNAKE_CASE__   =   0
     SCREAMING_SNAKE_CASE__   =   str(_A    )

     while len(_A    ) != 1:
          SCREAMING_SNAKE_CASE__   =   [int(_A    ) for i in num_string]

          SCREAMING_SNAKE_CASE__   =   1
          for i in range(0				,		len(_A    )    ):
               total *= numbers[i]

          SCREAMING_SNAKE_CASE__   =   str(_A    )

          steps += 1
     return steps
def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     if not isinstance(_A				,		_A    ):
          raise ValueError('''additive_persistence() only accepts integral values'''    )
     if num < 0:
          raise ValueError('''additive_persistence() does not accept negative values'''    )

     SCREAMING_SNAKE_CASE__   =   0
     SCREAMING_SNAKE_CASE__   =   str(_A    )

     while len(_A    ) != 1:
          SCREAMING_SNAKE_CASE__   =   [int(_A    ) for i in num_string]

          SCREAMING_SNAKE_CASE__   =   0
          for i in range(0				,		len(_A    )    ):
               total += numbers[i]

          SCREAMING_SNAKE_CASE__   =   str(_A    )

          steps += 1
     return steps


if __name__ == "__main__":
       import doctest

       doctest.testmod()


