
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			)









from collections.abc import Callable




class       snake_case__ :

       '''simple docstring'''



       def __init__(				self      ,    a__ = None     )			->   None:






            '''simple docstring'''





            __snake_case      :list 							=    []
            # Stores indexes of each item for supporting updates and deletion.
            __snake_case      :dict 							=    {}
            # Stores current size of heap.
            __snake_case      :List[Any] 							=    0
            # Stores function used to evaluate the score of an item on which basis ordering
            # will be done.
            __snake_case      :Optional[Any] 							=    key or (lambda a__     : x)



       def        __lowercase    (				self      ,    a__     )			->   int | None:






            '''simple docstring'''





            return int((i - 1) / 2     ) if i > 0 else None



       def        __lowercase    (				self      ,    a__     )			->   int | None:






            '''simple docstring'''





            __snake_case      :int 							=    int(2 * i + 1     )
            return left if 0 < left < self.size else None



       def        __lowercase    (				self      ,    a__     )			->   int | None:






            '''simple docstring'''





            __snake_case      :Optional[int] 							=    int(2 * i + 2     )
            return right if 0 < right < self.size else None



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case							,			__snake_case      :Dict 							=    (
                self.pos_map[self.arr[j][0]],
                self.pos_map[self.arr[i][0]],
            )
            # Then swap the items in the list.
            __snake_case							,			__snake_case      :Tuple 							=    self.arr[j], self.arr[i]



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   bool:






            '''simple docstring'''





            return self.arr[i][1] < self.arr[j][1]



       def        __lowercase    (				self      ,    a__     )			->   int:






            '''simple docstring'''





            __snake_case      :int 							=    self._left(a__     )
            __snake_case      :Optional[int] 							=    self._right(a__     )
            __snake_case      :List[Any] 							=    i

            if left is not None and not self._cmp(a__      ,    a__     ):
                 __snake_case      :int 							=    left
            if right is not None and not self._cmp(a__      ,    a__     ):
                 __snake_case      :Tuple 							=    right

            return valid_parent



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :int 							=    self._parent(a__     )
            while parent is not None and not self._cmp(a__      ,    a__     ):
                 self._swap(a__      ,    a__     )
                 __snake_case							,			__snake_case      :str 							=    parent, self._parent(a__     )



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :List[Any] 							=    self._get_valid_parent(a__     )
            while valid_parent != index:
                 self._swap(a__      ,    a__     )
                 __snake_case							,			__snake_case      :Optional[int] 							=    valid_parent, self._get_valid_parent(a__     )



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   None:






            '''simple docstring'''





            if item not in self.pos_map:
                 return
            __snake_case      :List[Any] 							=    self.pos_map[item]
            __snake_case      :Optional[Any] 							=    [item, self.key(a__     )]
            # Make sure heap is right in both up and down direction.
            # Ideally only one of them will make any change.
            self._heapify_up(a__     )
            self._heapify_down(a__     )



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            if item not in self.pos_map:
                 return
            __snake_case      :Dict 							=    self.pos_map[item]
            del self.pos_map[item]
            __snake_case      :Dict 							=    self.arr[self.size - 1]
            __snake_case      :List[str] 							=    index
            self.size -= 1
            # Make sure heap is right in both up and down direction. Ideally only one
            # of them will make any change- so no performance loss in calling both.
            if self.size > index:
                 self._heapify_up(a__     )
                 self._heapify_down(a__     )



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :Optional[int] 							=    len(self.arr     )
            if arr_len == self.size:
                 self.arr.append([item, self.key(a__     )]     )
            else:
                 __snake_case      :Optional[Any] 							=    [item, self.key(a__     )]
            __snake_case      :str 							=    self.size
            self.size += 1
            self._heapify_up(self.size - 1     )



       def        __lowercase    (				self     )			->   tuple | None:






            '''simple docstring'''





            return self.arr[0] if self.size else None



       def        __lowercase    (				self     )			->   tuple | None:






            '''simple docstring'''





            __snake_case      :Optional[Any] 							=    self.get_top()
            if top_item_tuple:
                 self.delete_item(top_item_tuple[0]     )
            return top_item_tuple






def 	UpperCamelCase	(							):




     '''simple docstring'''








if __name__ == "__main__":
     import doctest

     doctest.testmod()


