




import os
import random
import sys

from . import cryptomath_module as cryptoMath  # noqa: N812
from . import rabin_miller as rabinMiller  # noqa: N812





def 		__A		(	)      ->       None:
	print("""Making key files..."""    )
	make_key_files("""rsa"""							,			1024    )
	print("""Key files generation successful."""    )





def 		__A		(	__lowerCamelCase    )      ->       tuple[tuple[int, int], tuple[int, int]]:
	print("""Generating prime p..."""    )
	a										=							rabinMiller.generate_large_prime(__lowerCamelCase    )
	print("""Generating prime q..."""    )
	a										=							rabinMiller.generate_large_prime(__lowerCamelCase    )
	a										=							p * q

	print("""Generating e that is relatively prime to (p - 1) * (q - 1)..."""    )
	while True:
		a										=							random.randrange(2 ** (key_size - 1)							,			2 ** (key_size)    )
		if cryptoMath.gcd(__lowerCamelCase							,			(p - 1) * (q - 1)    ) == 1:
			break

	print("""Calculating d that is mod inverse of e..."""    )
	a										=							cryptoMath.find_mod_inverse(__lowerCamelCase							,			(p - 1) * (q - 1)    )

	a										=							(n, e)
	a										=							(n, d)
	return (public_key, private_key)





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase    )      ->       None:
	if os.path.exists(f'{name}_pubkey.txt'    ) or os.path.exists(f'{name}_privkey.txt'    ):
		print("""\nWARNING:"""    )
		print(
		    f'"{name}_pubkey.txt" or "{name}_privkey.txt" already exists. \n'
		    """Use a different name or delete these files and re-run this program."""    )
		sys.exit()

	a				, a										=							generate_key(__lowerCamelCase    )
	print(f'\nWriting public key to file {name}_pubkey.txt...'    )
	with open(f'{name}_pubkey.txt'							,			"""w"""    ) as out_file:
		out_file.write(f'{key_size},{public_key[0]},{public_key[1]}'    )

	print(f'Writing private key to file {name}_privkey.txt...'    )
	with open(f'{name}_privkey.txt'							,			"""w"""    ) as out_file:
		out_file.write(f'{key_size},{private_key[0]},{private_key[1]}'    )


if __name__ == "__main__":
		main()







import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp





def 		__A		(	)      ->       Any:
	a										=							ArgumentParser(
	    description=(
	        """PyTorch TPU distributed training launch """
	        """helper utility that will spawn up """
	        """multiple distributed processes"""
	    )    )

	# Optional arguments for the launch helper
	parser.add_argument("""--num_cores"""							,			type=__lowerCamelCase							,			default=1							,			help="""Number of TPU cores to use (1 or 8)."""    )

	# positional
	parser.add_argument(
	    """training_script"""							,			type=__lowerCamelCase							,			help=(
	        """The full path to the single TPU training """
	        """program/script to be launched in parallel, """
	        """followed by all the arguments for the """
	        """training script"""
	    )							,			)

	# rest from the training program
	parser.add_argument("""training_script_args"""							,			nargs=__lowerCamelCase    )

	return parser.parse_args()





def 		__A		(	)      ->       Union[str, Any]:
	a										=							parse_args()

	# Import training_script as a module.
	a										=							Path(args.training_script    )
	sys.path.append(str(script_fpath.parent.resolve()    )    )
	a										=							script_fpath.stem
	a										=							importlib.import_module(__lowerCamelCase    )

	# Patch sys.argv
	a										=							[args.training_script] + args.training_script_args + ["""--tpu_num_cores""", str(args.num_cores    )]
	xmp.spawn(mod._mp_fn							,			args=()							,			nprocs=args.num_cores    )


if __name__ == "__main__":
		main()

