

import numpy as np

_lowerCAmelCase					:			str  				=			[
    ["a", "b", "c", "d", "e"],
    ["f", "g", "h", "i", "k"],
    ["l", "m", "n", "o", "p"],
    ["q", "r", "s", "t", "u"],
    ["v", "w", "x", "y", "z"],
]






class 	__magic_name__    :





			def __init__(		self					)   -> None:




						'''simple docstring'''
						__a        =np.array(__snake_case					)





			def 		__magic_name__    (		self					,  __snake_case					)   -> np.ndarray:




						'''simple docstring'''
						__a      ,    __a        =np.where(letter == self.SQUARE					)
						__a        =np.concatenate([indexa + 1, indexa + 1]					)
						return indexes





			def 		__magic_name__    (		self					,  __snake_case					,  __snake_case					)   -> str:




						'''simple docstring'''
						__a        =self.SQUARE[indexa - 1, indexa - 1]
						return letter





			def 		__magic_name__    (		self					,  __snake_case					)   -> str:




						'''simple docstring'''
						__a        =message.lower()
						__a        =message.replace(' '					,  ''					)
						__a        =message.replace('j'					,  'i'					)

						__a        =np.empty((2, len(__snake_case					))					)
						for letter_index in range(len(__snake_case					)					):
									__a        =self.letter_to_numbers(message[letter_index]					)

									__a        =numbers[0]
									__a        =numbers[1]

						__a        =first_step.reshape(2 * len(__snake_case					)					)
						__a        =''
						for numbers_index in range(len(__snake_case					)					):
									__a        =int(second_step[numbers_index * 2]					)
									__a        =int(second_step[(numbers_index * 2) + 1]					)
									__a        =self.numbers_to_letter(__snake_case					,  __snake_case					)
									__a        =encoded_message + letter

						return encoded_message





			def 		__magic_name__    (		self					,  __snake_case					)   -> str:




						'''simple docstring'''
						__a        =message.lower()
						message.replace(' '					,  ''					)
						__a        =np.empty(2 * len(__snake_case					)					)
						for letter_index in range(len(__snake_case					)					):
									__a        =self.letter_to_numbers(message[letter_index]					)
									__a        =numbers[0]
									__a        =numbers[1]

						__a        =first_step.reshape((2, len(__snake_case					))					)
						__a        =''
						for numbers_index in range(len(__snake_case					)					):
									__a        =int(second_step[0, numbers_index]					)
									__a        =int(second_step[1, numbers_index]					)
									__a        =self.numbers_to_letter(__snake_case					,  __snake_case					)
									__a        =decoded_message + letter

						return decoded_message









import argparse

import torch

from transformers import OpenAIGPTConfig, OpenAIGPTModel, load_tf_weights_in_openai_gpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()






def        UpperCamelCase_(							_snake_case   :  Dict       ,     _snake_case   :  Optional[int]       ,     _snake_case   :  str	):




			"""simple docstring"""






			if openai_config_file == "":
						__a        =OpenAIGPTConfig()
			else:
						__a        =OpenAIGPTConfig.from_json_file(_snake_case	)
			__a        =OpenAIGPTModel(_snake_case	)

			# Load weights from numpy
			load_tf_weights_in_openai_gpt(_snake_case       ,     _snake_case       ,     _snake_case	)

			# Save pytorch-model
			__a        =pytorch_dump_folder_path + '/' + WEIGHTS_NAME
			__a        =pytorch_dump_folder_path + '/' + CONFIG_NAME
			print(F'Save PyTorch model to {pytorch_weights_dump_path}'	)
			torch.save(model.state_dict()       ,     _snake_case	)
			print(F'Save configuration file to {pytorch_config_dump_path}'	)
			with open(_snake_case       ,     'w'       ,     encoding='utf-8'	) as f:
						f.write(config.to_json_string()	)


if __name__ == "__main__":
						_lowerCAmelCase					:			Tuple  				=			argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    "--openai_checkpoint_folder_path",
						    default=None,
						    type=str,
						    required=True,
						    help="Path to the TensorFlow checkpoint path.",
						)
						parser.add_argument(
						    "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
						)
						parser.add_argument(
						    "--openai_config_file",
						    default="",
						    type=str,
						    help=(
						        "An optional config json file corresponding to the pre-trained OpenAI model. \n"
						        "This specifies the model architecture."
						    ),
						)
						_lowerCAmelCase					:			int  				=			parser.parse_args()
						convert_openai_checkpoint_to_pytorch(
						    args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
						)






