





import argparse

import torch

from transformers import GPTaConfig, GPTaModel, load_tf_weights_in_gpta
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

def   __snake_case    (       _lowerCAmelCase			:			str					,					_lowerCAmelCase			:			List[Any]					,					_lowerCAmelCase			:			List[str]						)			->    List[str]:
   # Construct model
   if gpta_config_file == "":
      A_       :					int        =      GPTaConfig()
   else:
      A_       :					Tuple        =      GPTaConfig.from_json_file(_lowerCAmelCase						)
   A_       :					str        =      GPTaModel(_lowerCAmelCase						)

   # Load weights from numpy
   load_tf_weights_in_gpta(_lowerCAmelCase					,					_lowerCAmelCase					,					_lowerCAmelCase						)

   # Save pytorch-model
   A_       :					Optional[Any]        =      pytorch_dump_folder_path + "/" + WEIGHTS_NAME
   A_       :					Union[str, Any]        =      pytorch_dump_folder_path + "/" + CONFIG_NAME
   print(f"Save PyTorch model to {pytorch_weights_dump_path}"						)
   torch.save(model.state_dict()					,					_lowerCAmelCase						)
   print(f"Save configuration file to {pytorch_config_dump_path}"						)
   with open(_lowerCAmelCase					,					"w"					,					encoding="utf-8"						) as f:
      f.write(config.to_json_string()						)


if __name__ == "__main__":
 _lowerCAmelCase				:   str						       =						argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '''--gpt2_checkpoint_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(
     '''--gpt2_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_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)







def   __snake_case    (       _lowerCAmelCase			:			int = 1					,					_lowerCAmelCase			:			int = 1000						)			->    int:
   A_       :					Optional[int]        =      1
   A_       :					int        =      0

   for divide_by_number in range(_lowerCAmelCase					,					digit + 1						):
      A_       :					list[int]        =      []
      A_       :					Union[str, Any]        =      numerator
      for _ in range(1					,					digit + 1						):
         if now_divide in has_been_divided:
            if longest_list_length < len(_lowerCAmelCase						):
               A_       :					Optional[Any]        =      len(_lowerCAmelCase						)
               A_       :					Union[str, Any]        =      divide_by_number
         else:
            has_been_divided.append(_lowerCAmelCase						)
            A_       :					Dict        =      now_divide * 10 % divide_by_number

   return the_digit


# Tests
if __name__ == "__main__":
 import doctest

 doctest.testmod()
