code: from __future__ import annotations
  
  import unittest
  
  from transformers import OpenAIGPTConfig, 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.models.openai.modeling_tf_openai import (
  		    TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
  		    TFOpenAIGPTDoubleHeadsModel,
  		    TFOpenAIGPTForSequenceClassification,
  		    TFOpenAIGPTLMHeadModel,
  		    TFOpenAIGPTModel,
  		)
  
  
  
  
  class 					UpperCamelCase	:
  
  
  
  
  					def __init__( self :					Any      ,_lowerCAmelCase :					Optional[int]      ,):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     parent
  							__snake_case		       =     13
  							__snake_case		       =     7
  							__snake_case		       =     True
  							__snake_case		       =     True
  							__snake_case		       =     True
  							__snake_case		       =     True
  							__snake_case		       =     True
  							__snake_case		       =     99
  							__snake_case		       =     32
  							__snake_case		       =     2
  							__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.0_2
  							__snake_case		       =     3
  							__snake_case		       =     4
  							__snake_case		       =     None
  							__snake_case		       =     self.vocab_size - 1
  
  
  
  
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size						)
  
  							__snake_case		       =     None
  							if self.use_input_mask:
  									__snake_case		       =     random_attention_mask([self.batch_size, self.seq_length]						)
  
  							__snake_case		       =     None
  							if self.use_token_type_ids:
  									__snake_case		       =     ids_tensor([self.batch_size, self.seq_length]      ,self.type_vocab_size						)
  
  							__snake_case		       =     None
  							if self.use_mc_token_ids:
  									__snake_case		       =     ids_tensor([self.batch_size, self.num_choices]      ,self.seq_length						)
  
  							__snake_case		       =     None
  							__snake_case		       =     None
  							__snake_case		       =     None
  							if self.use_labels:
  									__snake_case		       =     ids_tensor([self.batch_size]      ,self.type_sequence_label_size						)
  									__snake_case		       =     ids_tensor([self.batch_size, self.seq_length]      ,self.num_labels						)
  									__snake_case		       =     ids_tensor([self.batch_size]      ,self.num_choices						)
  
  							__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      ,)
  
  							__snake_case		       =     ids_tensor([self.num_hidden_layers, self.num_attention_heads]      ,2						)
  
  							return (
  							    config,
  							    input_ids,
  							    input_mask,
  							    head_mask,
  							    token_type_ids,
  							    mc_token_ids,
  							    sequence_labels,
  							    token_labels,
  							    choice_labels,
  							)
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Any      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					str      ,_lowerCAmelCase :					List[Any]      ,*_lowerCAmelCase :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     TFOpenAIGPTModel(config=_lowerCAmelCase						)
  							__snake_case		       =     {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
  							__snake_case		       =     model(_lowerCAmelCase						)
  
  							__snake_case		       =     [input_ids, input_mask]
  							__snake_case		       =     model(_lowerCAmelCase						)
  
  							__snake_case		       =     model(_lowerCAmelCase						)
  
  							self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, self.seq_length, self.hidden_size)						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					str      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					Union[str, Any]      ,_lowerCAmelCase :					str      ,*_lowerCAmelCase :					str						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     TFOpenAIGPTLMHeadModel(config=_lowerCAmelCase						)
  							__snake_case		       =     {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
  							__snake_case		       =     model(_lowerCAmelCase						)
  							self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.vocab_size)						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					Union[str, Any]      ,_lowerCAmelCase :					int      ,_lowerCAmelCase :					List[Any]      ,_lowerCAmelCase :					Optional[Any]      ,_lowerCAmelCase :					Optional[Any]      ,*_lowerCAmelCase :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     TFOpenAIGPTDoubleHeadsModel(config=_lowerCAmelCase						)
  
  							__snake_case		       =     tf.tile(tf.expand_dims(_lowerCAmelCase      ,1						)      ,(1, self.num_choices, 1)						)
  							__snake_case		       =     tf.tile(tf.expand_dims(_lowerCAmelCase      ,1						)      ,(1, self.num_choices, 1)						)
  							__snake_case		       =     tf.tile(tf.expand_dims(_lowerCAmelCase      ,1						)      ,(1, self.num_choices, 1)						)
  
  							__snake_case		       =     {
  							    "input_ids": multiple_choice_inputs_ids,
  							    "mc_token_ids": mc_token_ids,
  							    "attention_mask": multiple_choice_input_mask,
  							    "token_type_ids": multiple_choice_token_type_ids,
  							}
  							__snake_case		       =     model(_lowerCAmelCase						)
  							self.parent.assertEqual(
  							    result.logits.shape      ,(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)						)
  							self.parent.assertEqual(result.mc_logits.shape      ,(self.batch_size, self.num_choices)						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple      ,_lowerCAmelCase :					int      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Tuple      ,_lowerCAmelCase :					Dict      ,_lowerCAmelCase :					List[Any]      ,*_lowerCAmelCase :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.num_labels
  							__snake_case		       =     ids_tensor([self.batch_size]      ,self.type_sequence_label_size						)
  							__snake_case		       =     {
  							    "input_ids": input_ids,
  							    "attention_mask": input_mask,
  							    "token_type_ids": token_type_ids,
  							    "labels": sequence_labels,
  							}
  							__snake_case		       =     TFOpenAIGPTForSequenceClassification(_lowerCAmelCase						)
  							__snake_case		       =     model(_lowerCAmelCase						)
  							self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_labels)						)
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.prepare_config_and_inputs()
  
  							(
  							    (
  							    __snake_case
  							)       ,       (
  							    __snake_case
  							)       ,       (
  							    __snake_case
  							)       ,       (
  							    __snake_case
  							)       ,       (
  							    __snake_case
  							)       ,       (
  							    __snake_case
  							)       ,       (
  							    __snake_case
  							)       ,       (
  							    __snake_case
  							)       ,       (
  							    __snake_case
  							)       ,       
  							)		       =     config_and_inputs
  
  							__snake_case		       =     {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
  							return config, inputs_dict
  
  
  
  
  @require_tf
  class 					UpperCamelCase	(     snake_case__			,      snake_case__			,      unittest.TestCase      ):
  					__UpperCamelCase						=   (
  					    (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
  					    if is_tf_available()
  					    else ()
  					)
  					__UpperCamelCase						=   (
  					    (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
  					)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
  					__UpperCamelCase						=   (
  					    {
  					        """feature-extraction""": TFOpenAIGPTModel,
  					        """text-classification""": TFOpenAIGPTForSequenceClassification,
  					        """text-generation""": TFOpenAIGPTLMHeadModel,
  					        """zero-shot""": TFOpenAIGPTForSequenceClassification,
  					    }
  					    if is_tf_available()
  					    else {}
  					)
  					__UpperCamelCase						=   False
  					__UpperCamelCase						=   False
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]      ,_lowerCAmelCase :					List[Any]      ,_lowerCAmelCase :					Optional[int]      ,_lowerCAmelCase :					Any      ,_lowerCAmelCase :					Optional[int]      ,_lowerCAmelCase :					str						):
  
  
  							"""simple docstring"""
  
  
  
  
  							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 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     TFOpenAIGPTModelTester(self						)
  							__snake_case		       =     ConfigTester(self      ,config_class=_lowerCAmelCase      ,n_embd=37						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							self.config_tester.run_common_tests()
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.model_tester.prepare_config_and_inputs()
  							self.model_tester.create_and_check_openai_gpt_model(*_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.model_tester.prepare_config_and_inputs()
  							self.model_tester.create_and_check_openai_gpt_lm_head(*_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Union[str, Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.model_tester.prepare_config_and_inputs()
  							self.model_tester.create_and_check_openai_gpt_double_head(*_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.model_tester.prepare_config_and_inputs()
  							self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_lowerCAmelCase						)
  
  
  
  
  
  
  
  					@slow
  					def 							UpperCamelCase_						( self :					Optional[int]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  									__snake_case		       =     TFOpenAIGPTModel.from_pretrained(_lowerCAmelCase						)
  									self.assertIsNotNone(_lowerCAmelCase						)
  
  
  
  
  @require_tf
  class 					UpperCamelCase	(     unittest.TestCase      ):
  
  
  
  
  					@slow
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     TFOpenAIGPTLMHeadModel.from_pretrained("openai-gpt"						)
  							__snake_case		       =     tf.convert_to_tensor([[481, 4_735, 544]]      ,dtype=tf.intaa						)  # the president is
  							__snake_case		       =     [
  							    481,
  							    4_735,
  							    544,
  							    246,
  							    963,
  							    870,
  							    762,
  							    239,
  							    244,
  							    40_477,
  							    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
  
  							__snake_case		       =     model.generate(_lowerCAmelCase      ,do_sample=_lowerCAmelCase						)
  							self.assertListEqual(output_ids[0].numpy().tolist()      ,_lowerCAmelCase						)
  
  
  
  
  
  
style_context: import os
  from string import ascii_letters
  
  lowerCamelCase__           =				ascii_letters + ' \t\n'
  
  
  
  def 							_lowerCamelCase(				)  ->   dict[str, None]:
  		__snake_case		       =     os.path.split(os.path.realpath(__snake_case	)	)
  		__snake_case		       =     {}
  		with open(path[0] + "/dictionary.txt"	) as dictionary_file:
  				for word in dictionary_file.read().split("\n"	):
  						__snake_case		       =     None
  		return english_words
  
  
  lowerCamelCase__           =				load_dictionary()
  
  
  
  def 							_lowerCamelCase(				__snake_case	)  ->   float:
  		__snake_case		       =     message.upper()
  		__snake_case		       =     remove_non_letters(__snake_case	)
  		__snake_case		       =     message.split()
  		__snake_case		       =     len([word for word in possible_words if word in ENGLISH_WORDS]	)
  		return float(__snake_case	) / len(__snake_case	)
  
  
  
  def 							_lowerCamelCase(				__snake_case	)  ->   str:
  		return "".join(symbol for symbol in message if symbol in LETTERS_AND_SPACE	)
  
  
  
  def 							_lowerCamelCase(				__snake_case						,						__snake_case = 20						,						__snake_case = 85	)  ->   bool:
  		__snake_case		       =     get_english_count(__snake_case	) * 100 >= word_percentage
  		__snake_case		       =     len(remove_non_letters(__snake_case	)	)
  		__snake_case		       =     (float(__snake_case	) / len(__snake_case	)) * 100
  		__snake_case		       =     message_letters_percentage >= letter_percentage
  		return words_match and letters_match
  
  
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  
  
  
  
  