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







						'''simple docstring'''



						def __init__( self       :List[str]		,						lowerCAmelCase__       :Dict		,						)     ->int:
								lowercase						    =			parent
								lowercase						    =			13
								lowercase						    =			7
								lowercase						    =			True
								lowercase						    =			True
								lowercase						    =			True
								lowercase						    =			True
								lowercase						    =			True
								lowercase						    =			99
								lowercase						    =			32
								lowercase						    =			2
								lowercase						    =			4
								lowercase						    =			37
								lowercase						    =			"gelu"
								lowercase						    =			0.1
								lowercase						    =			0.1
								lowercase						    =			512
								lowercase						    =			16
								lowercase						    =			2
								lowercase						    =			0.02
								lowercase						    =			3
								lowercase						    =			4
								lowercase						    =			None
								lowercase						    =			self.vocab_size - 1





						def 					SCREAMING_SNAKE_CASE( self       :Tuple    )     ->List[Any]:
								lowercase						    =			ids_tensor([self.batch_size, self.seq_length]		,						self.vocab_size    )

								lowercase						    =			None
								if self.use_input_mask:
										lowercase						    =			random_attention_mask([self.batch_size, self.seq_length]    )

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

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

								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,
								    input_mask,
								    head_mask,
								    token_type_ids,
								    mc_token_ids,
								    sequence_labels,
								    token_labels,
								    choice_labels,
								)





						def 					SCREAMING_SNAKE_CASE( self       :Any		,						lowerCAmelCase__       :str		,						lowerCAmelCase__       :Dict		,						lowerCAmelCase__       :List[Any]		,						lowerCAmelCase__       :Dict		,						lowerCAmelCase__       :Any		,						*lowerCAmelCase__       :Optional[int]    )     ->Optional[Any]:
								lowercase						    =			TFOpenAIGPTModel(config=lowerCAmelCase__    )
								lowercase						    =			{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
								lowercase						    =			model(lowerCAmelCase__    )

								lowercase						    =			[input_ids, input_mask]
								lowercase						    =			model(lowerCAmelCase__    )

								lowercase						    =			model(lowerCAmelCase__    )

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





						def 					SCREAMING_SNAKE_CASE( self       :Any		,						lowerCAmelCase__       :Any		,						lowerCAmelCase__       :Any		,						lowerCAmelCase__       :List[str]		,						lowerCAmelCase__       :int		,						lowerCAmelCase__       :List[str]		,						*lowerCAmelCase__       :int    )     ->Union[str, Any]:
								lowercase						    =			TFOpenAIGPTLMHeadModel(config=lowerCAmelCase__    )
								lowercase						    =			{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
								lowercase						    =			model(lowerCAmelCase__    )
								self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.seq_length, self.vocab_size)    )





						def 					SCREAMING_SNAKE_CASE( self       :int		,						lowerCAmelCase__       :Tuple		,						lowerCAmelCase__       :Tuple		,						lowerCAmelCase__       :Dict		,						lowerCAmelCase__       :Tuple		,						lowerCAmelCase__       :List[Any]		,						lowerCAmelCase__       :Dict		,						*lowerCAmelCase__       :str    )     ->Optional[int]:
								lowercase						    =			TFOpenAIGPTDoubleHeadsModel(config=lowerCAmelCase__    )

								lowercase						    =			tf.tile(tf.expand_dims(lowerCAmelCase__		,						1    )		,						(1, self.num_choices, 1)    )
								lowercase						    =			tf.tile(tf.expand_dims(lowerCAmelCase__		,						1    )		,						(1, self.num_choices, 1)    )
								lowercase						    =			tf.tile(tf.expand_dims(lowerCAmelCase__		,						1    )		,						(1, self.num_choices, 1)    )

								lowercase						    =			{
								    "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,
								}
								lowercase						    =			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 					SCREAMING_SNAKE_CASE( self       :str		,						lowerCAmelCase__       :Tuple		,						lowerCAmelCase__       :Tuple		,						lowerCAmelCase__       :List[str]		,						lowerCAmelCase__       :List[Any]		,						lowerCAmelCase__       :Any		,						*lowerCAmelCase__       :List[Any]    )     ->str:
								lowercase						    =			self.num_labels
								lowercase						    =			ids_tensor([self.batch_size]		,						self.type_sequence_label_size    )
								lowercase						    =			{
								    "input_ids": input_ids,
								    "attention_mask": input_mask,
								    "token_type_ids": token_type_ids,
								    "labels": sequence_labels,
								}
								lowercase						    =			TFOpenAIGPTForSequenceClassification(lowerCAmelCase__    )
								lowercase						    =			model(lowerCAmelCase__    )
								self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_labels)    )





						def 					SCREAMING_SNAKE_CASE( self       :List[Any]    )     ->Dict:
								lowercase						    =			self.prepare_config_and_inputs()

								(
								    (
								    lowercase  
								)    ,  (
								    lowercase  
								)    ,  (
								    lowercase  
								)    ,  (
								    lowercase  
								)    ,  (
								    lowercase  
								)    ,  (
								    lowercase  
								)    ,  (
								    lowercase  
								)    ,  (
								    lowercase  
								)    ,  (
								    lowercase  
								)    ,    
								)						    =			config_and_inputs

								lowercase						    =			{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
								return config, inputs_dict





@require_tf
class      UpperCamelCase_			(			__a		,						__a		,						unittest.TestCase		):







						'''simple docstring'''



						UpperCamelCase			:     int							      =				(
						    (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
						    if is_tf_available()
						    else ()
						)
						UpperCamelCase			:     Dict							      =				(
						    (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
						)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
						UpperCamelCase			:     List[Any]							      =				(
						    {
						        '''feature-extraction''': TFOpenAIGPTModel,
						        '''text-classification''': TFOpenAIGPTForSequenceClassification,
						        '''text-generation''': TFOpenAIGPTLMHeadModel,
						        '''zero-shot''': TFOpenAIGPTForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						UpperCamelCase			:     Tuple							      =				False
						UpperCamelCase			:     Dict							      =				False





						def 					SCREAMING_SNAKE_CASE( self       :Optional[int]		,						lowerCAmelCase__       :Tuple		,						lowerCAmelCase__       :str		,						lowerCAmelCase__       :List[Any]		,						lowerCAmelCase__       :Union[str, Any]		,						lowerCAmelCase__       :List[Any]    )     ->Tuple:
								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       :str    )     ->List[Any]:
								lowercase						    =			TFOpenAIGPTModelTester(self    )
								lowercase						    =			ConfigTester(self		,						config_class=lowerCAmelCase__		,						n_embd=37    )





						def 					SCREAMING_SNAKE_CASE( self       :Tuple    )     ->Optional[Any]:
								self.config_tester.run_common_tests()





						def 					SCREAMING_SNAKE_CASE( self       :Optional[Any]    )     ->Optional[Any]:
								lowercase						    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_openai_gpt_model(*lowerCAmelCase__    )





						def 					SCREAMING_SNAKE_CASE( self       :Optional[Any]    )     ->Any:
								lowercase						    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_openai_gpt_lm_head(*lowerCAmelCase__    )





						def 					SCREAMING_SNAKE_CASE( self       :Any    )     ->List[Any]:
								lowercase						    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_openai_gpt_double_head(*lowerCAmelCase__    )





						def 					SCREAMING_SNAKE_CASE( self       :Tuple    )     ->Optional[Any]:
								lowercase						    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowerCAmelCase__    )





						@slow
						def 					SCREAMING_SNAKE_CASE( self       :Optional[int]    )     ->Tuple:
								for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowercase						    =			TFOpenAIGPTModel.from_pretrained(lowerCAmelCase__    )
										self.assertIsNotNone(lowerCAmelCase__    )





@require_tf
class      UpperCamelCase_			(			unittest.TestCase		):







						'''simple docstring'''



						@slow
						def 					SCREAMING_SNAKE_CASE( self       :int    )     ->str:
								lowercase						    =			TFOpenAIGPTLMHeadModel.from_pretrained("openai-gpt"    )
								lowercase						    =			tf.convert_to_tensor([[481, 4735, 544]]		,						dtype=tf.intaa    )  # the president is
								lowercase						    =			[
								    481,
								    4735,
								    544,
								    246,
								    963,
								    870,
								    762,
								    239,
								    244,
								    40477,
								    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(lowerCAmelCase__		,						do_sample=lowerCAmelCase__    )
								self.assertListEqual(output_ids[0].numpy().tolist()		,						lowerCAmelCase__    )


_snake_case			:       List[Any]      =						{
    "A": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
    "B": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
    "C": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
    "D": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
    "E": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
    "F": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
    "G": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
    "H": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
    "I": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
    "J": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
    "K": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
    "L": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
    "M": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
    "N": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
    "O": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
    "P": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
    "Q": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
    "R": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
    "S": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
    "T": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
    "U": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
    "V": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
    "W": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
    "X": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
    "Y": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
    "Z": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
}

def    __snake_case       (  __magic_name__	):







				'''simple docstring'''


				return [alphabet[char] for char in key.upper()]

def    __snake_case       (  __magic_name__		,						__magic_name__	):







				'''simple docstring'''


				lowercase						    =			""
				lowercase						    =			0
				lowercase						    =			generate_table(__magic_name__	)
				for char in words.upper():
								cipher += get_opponent(table[count]		,						__magic_name__	)
								lowercase						    =			(count + 1) % len(__magic_name__	)
				return cipher

def    __snake_case       (  __magic_name__		,						__magic_name__	):







				'''simple docstring'''


				return encrypt(__magic_name__		,						__magic_name__	)

def    __snake_case       (  __magic_name__		,						__magic_name__	):







				'''simple docstring'''


				lowercase						    =			0 if char in table[0] else 1
				lowercase						    =			table[row].index(__magic_name__	)
				return row, col

def    __snake_case       (  __magic_name__		,						__magic_name__	):







				'''simple docstring'''


				lowercase    ,  lowercase						    =			get_position(__magic_name__		,						char.upper()	)
				if row == 1:
								return table[0][col]
				else:
								return table[1][col] if row == 0 else char


if __name__ == "__main__":
						import doctest

						doctest.testmod()  # Fist ensure that all our tests are passing...
						_snake_case			:       List[Any]      =						input("Enter key: ").strip()
						_snake_case			:       Optional[int]      =						input("Enter text to encrypt: ").strip()
						_snake_case			:       Optional[Any]      =						encrypt(key, text)

						print(F"Encrypted: {cipher_text}")
						print(F"Decrypted with key: {decrypt(key, cipher_text)}")
