





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    __UpperCAmelCase(      lowercase_ ,    lowercase_ ,    lowercase_      ):
							# Construct model
							if gpta_config_file == "":
														_lowerCamelCase							:     Union[str, Any]	=		GPTaConfig()
							else:
														_lowerCamelCase							:     Optional[int]	=		GPTaConfig.from_json_file(lowercase_      )
							_lowerCamelCase							:     Optional[int]	=		GPTaModel(lowercase_      )

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

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


if __name__ == "__main__":
							_lowerCamelCase			       =      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			       =      parser.parse_args()
							convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)








import unittest

from knapsack import knapsack as k







class 			__A       (      unittest.TestCase  ):




      """simple docstring"""







      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Dict	=		0
             _lowerCamelCase							:     int	=		[0]
             _lowerCamelCase							:     Optional[int]	=		[0]
             _lowerCamelCase							:     Dict	=		len(a__)
             self.assertEqual(k.knapsack(a__      ,							a__      ,							a__      ,							a__)      ,							0)

             _lowerCamelCase							:     str	=		[60]
             _lowerCamelCase							:     List[str]	=		[10]
             _lowerCamelCase							:     List[Any]	=		len(a__)
             self.assertEqual(k.knapsack(a__      ,							a__      ,							a__      ,							a__)      ,							0)


      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Union[str, Any]	=		3
             _lowerCamelCase							:     List[Any]	=		[1, 2, 3]
             _lowerCamelCase							:     Dict	=		[3, 2, 1]
             _lowerCamelCase							:     Any	=		len(a__)
             self.assertEqual(k.knapsack(a__      ,							a__      ,							a__      ,							a__)      ,							5)



      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Optional[Any]	=		50
             _lowerCamelCase							:     Dict	=		[60, 100, 120]
             _lowerCamelCase							:     Dict	=		[10, 20, 30]
             _lowerCamelCase							:     Union[str, Any]	=		len(a__)
             self.assertEqual(k.knapsack(a__      ,							a__      ,							a__      ,							a__)      ,							220)


if __name__ == "__main__":
       unittest.main()

