import argparse

import torch

from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
from transformers.utils import logging


logging.set_verbosity_info()






def 			__lowercase     (				a__							,     a__							,     a__							,     a__     )       ->				Any:
							# Initialise PyTorch model
							__SCREAMING_SNAKE_CASE								=      ElectraConfig.from_json_file(lowercase__     )
							print(f"""Building PyTorch model from configuration: {config}"""     )

							if discriminator_or_generator == "discriminator":
														__SCREAMING_SNAKE_CASE								=      ElectraForPreTraining(lowercase__     )
							elif discriminator_or_generator == "generator":
														__SCREAMING_SNAKE_CASE								=      ElectraForMaskedLM(lowercase__     )
							else:
														raise ValueError('The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''     )

							# Load weights from tf checkpoint
							load_tf_weights_in_electra(
							    lowercase__							,     lowercase__							,     lowercase__							,     discriminator_or_generator=lowercase__     )

							# Save pytorch-model
							print(f"""Save PyTorch model to {pytorch_dump_path}"""     )
							torch.save(model.state_dict()							,     lowercase__     )


if __name__ == "__main__":
			lowerCAmelCase__	:  List[Any] 		=argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
			)
			parser.add_argument(
			    '''--config_file''',
			    default=None,
			    type=str,
			    required=True,
			    help='''The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.''',
			)
			parser.add_argument(
			    '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
			)
			parser.add_argument(
			    '''--discriminator_or_generator''',
			    default=None,
			    type=str,
			    required=True,
			    help=(
			        '''Whether to export the generator or the discriminator. Should be a string, either \'discriminator\' or '''
			        '''\'generator\'.'''
			    ),
			)
			lowerCAmelCase__	:  Union[str, Any] 		=parser.parse_args()
			convert_tf_checkpoint_to_pytorch(
			    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
			)











def 			__lowercase     (				a__     )       ->				list:
							__SCREAMING_SNAKE_CASE								=      1.3
							__SCREAMING_SNAKE_CASE								=      len(a__     )
							__SCREAMING_SNAKE_CASE								=      False

							while not completed:
														# Update the gap value for a next comb
														__SCREAMING_SNAKE_CASE								=      int(gap / shrink_factor     )
														if gap <= 1:
																					__SCREAMING_SNAKE_CASE								=      True

														__SCREAMING_SNAKE_CASE								=      0
														while index + gap < len(a__     ):
																					if data[index] > data[index + gap]:
																												# Swap values
																												__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      data[index + gap], data[index]
																												__SCREAMING_SNAKE_CASE								=      False
																					index += 1

							return data


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			lowerCAmelCase__	:  int 		=input('''Enter numbers separated by a comma:\n''').strip()
			lowerCAmelCase__	:  Dict 		=[int(item) for item in user_input.split(''',''')]
			print(comb_sort(unsorted))






