




import os
import random
import sys

from . import cryptomath_module as cryptomath
from . import rabin_miller

a__		     =     3





def 				A__ (snake_case   :		int				)     ->						int:
					print("""Generating primitive root of p"""				)
					while True:
										__UpperCamelCase					:	Any             =      random.randrange(3		,	snake_case				)
										if pow(snake_case		,	2		,	snake_case				) == 1:
															continue
										if pow(snake_case		,	snake_case		,	snake_case				) == 1:
															continue
										return g





def 				A__ (snake_case   :		int				)     ->						tuple[tuple[int, int, int, int], tuple[int, int]]:
					print("""Generating prime p..."""				)
					__UpperCamelCase					:	Tuple             =      rabin_miller.generate_large_prime(snake_case				)  # select large prime number.
					__UpperCamelCase					:	int             =      primitive_root(snake_case				)  # one primitive root on modulo p.
					__UpperCamelCase					:	Optional[int]             =      random.randrange(3		,	snake_case				)  # private_key -> have to be greater than 2 for safety.
					__UpperCamelCase					:	Tuple             =      cryptomath.find_mod_inverse(pow(snake_case		,	snake_case		,	snake_case				)		,	snake_case				)

					__UpperCamelCase					:	List[str]             =      (key_size, e_a, e_a, p)
					__UpperCamelCase					:	Union[str, Any]             =      (key_size, d)

					return public_key, private_key





def 				A__ (snake_case   :		str		,	snake_case   :		int				)     ->						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()

					__UpperCamelCase      ,			__UpperCamelCase					:	int             =      generate_key(snake_case				)
					print(F'''\nWriting public key to file {name}_pubkey.txt...'''				)
					with open(F'''{name}_pubkey.txt'''		,	"""w"""				) as fo:
										fo.write(F'''{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}'''				)

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





def 				A__ ()     ->						None:
					print("""Making key files..."""				)
					make_key_files("""elgamal"""		,	20_48				)
					print("""Key files generation successful"""				)


if __name__ == "__main__":
	main()












from tempfile import TemporaryDirectory
from unittest import TestCase
from unittest.mock import MagicMock, patch

from transformers import AutoModel, TFAutoModel
from transformers.onnx import FeaturesManager
from transformers.testing_utils import SMALL_MODEL_IDENTIFIER, require_tf, require_torch


@require_torch
@require_tf
class    SCREAMING_SNAKE_CASE_				(       _UpperCamelCase   ):



	"""simple docstring"""


	def 					lowerCamelCase__     (					self		:						Dict	)	->       List[Any]:







						"""simple docstring"""







						__UpperCamelCase					:	Optional[Any]             =      SMALL_MODEL_IDENTIFIER
						__UpperCamelCase					:	List[str]             =      """pt"""
						__UpperCamelCase					:	List[Any]             =      """tf"""






	def 					lowerCamelCase__     (					self		:						Any					,     lowerCAmelCase		:						List[Any]	)	->       List[Any]:







						"""simple docstring"""







						__UpperCamelCase					:	str             =      AutoModel.from_pretrained(self.test_model	)
						model_pt.save_pretrained(lowerCAmelCase	)






	def 					lowerCamelCase__     (					self		:						List[Any]					,     lowerCAmelCase		:						Any	)	->       Optional[Any]:







						"""simple docstring"""







						__UpperCamelCase					:	List[str]             =      TFAutoModel.from_pretrained(self.test_model					,     from_pt=lowerCAmelCase	)
						model_tf.save_pretrained(lowerCAmelCase	)






	def 					lowerCamelCase__     (					self		:						str	)	->       Tuple:







						"""simple docstring"""







						__UpperCamelCase					:	Any             =      """mock_framework"""

						# Framework provided - return whatever the user provides
						__UpperCamelCase					:	List[Any]             =      FeaturesManager.determine_framework(self.test_model					,     lowerCAmelCase	)
						self.assertEqual(lowerCAmelCase					,     lowerCAmelCase	)

						# Local checkpoint and framework provided - return provided framework
						# PyTorch checkpoint
						with TemporaryDirectory() as local_pt_ckpt:
											self._setup_pt_ckpt(lowerCAmelCase	)
											__UpperCamelCase					:	Union[str, Any]             =      FeaturesManager.determine_framework(lowerCAmelCase					,     lowerCAmelCase	)
											self.assertEqual(lowerCAmelCase					,     lowerCAmelCase	)

						# TensorFlow checkpoint
						with TemporaryDirectory() as local_tf_ckpt:
											self._setup_tf_ckpt(lowerCAmelCase	)
											__UpperCamelCase					:	Any             =      FeaturesManager.determine_framework(lowerCAmelCase					,     lowerCAmelCase	)
											self.assertEqual(lowerCAmelCase					,     lowerCAmelCase	)






	def 					lowerCamelCase__     (					self		:						Optional[Any]	)	->       str:







						"""simple docstring"""







						with TemporaryDirectory() as local_pt_ckpt:
											self._setup_pt_ckpt(lowerCAmelCase	)
											__UpperCamelCase					:	Optional[Any]             =      FeaturesManager.determine_framework(lowerCAmelCase	)
											self.assertEqual(lowerCAmelCase					,     self.framework_pt	)

						# TensorFlow checkpoint
						with TemporaryDirectory() as local_tf_ckpt:
											self._setup_tf_ckpt(lowerCAmelCase	)
											__UpperCamelCase					:	Union[str, Any]             =      FeaturesManager.determine_framework(lowerCAmelCase	)
											self.assertEqual(lowerCAmelCase					,     self.framework_tf	)

						# Invalid local checkpoint
						with TemporaryDirectory() as local_invalid_ckpt:
											with self.assertRaises(lowerCAmelCase	):
																__UpperCamelCase					:	int             =      FeaturesManager.determine_framework(lowerCAmelCase	)






	def 					lowerCamelCase__     (					self		:						Dict	)	->       Tuple:







						"""simple docstring"""







						__UpperCamelCase					:	str             =      MagicMock(return_value=lowerCAmelCase	)
						with patch("""transformers.onnx.features.is_tf_available"""					,     lowerCAmelCase	):
											__UpperCamelCase					:	Any             =      FeaturesManager.determine_framework(self.test_model	)
											self.assertEqual(lowerCAmelCase					,     self.framework_pt	)

						# PyTorch not in environment -> use TensorFlow
						__UpperCamelCase					:	Optional[int]             =      MagicMock(return_value=lowerCAmelCase	)
						with patch("""transformers.onnx.features.is_torch_available"""					,     lowerCAmelCase	):
											__UpperCamelCase					:	Any             =      FeaturesManager.determine_framework(self.test_model	)
											self.assertEqual(lowerCAmelCase					,     self.framework_tf	)

						# Both in environment -> use PyTorch
						__UpperCamelCase					:	Dict             =      MagicMock(return_value=lowerCAmelCase	)
						__UpperCamelCase					:	Any             =      MagicMock(return_value=lowerCAmelCase	)
						with patch("""transformers.onnx.features.is_tf_available"""					,     lowerCAmelCase	), patch(
						    """transformers.onnx.features.is_torch_available"""					,     lowerCAmelCase	):
											__UpperCamelCase					:	int             =      FeaturesManager.determine_framework(self.test_model	)
											self.assertEqual(lowerCAmelCase					,     self.framework_pt	)

						# Both not in environment -> raise error
						__UpperCamelCase					:	Union[str, Any]             =      MagicMock(return_value=lowerCAmelCase	)
						__UpperCamelCase					:	Tuple             =      MagicMock(return_value=lowerCAmelCase	)
						with patch("""transformers.onnx.features.is_tf_available"""					,     lowerCAmelCase	), patch(
						    """transformers.onnx.features.is_torch_available"""					,     lowerCAmelCase	):
											with self.assertRaises(lowerCAmelCase	):
																__UpperCamelCase					:	str             =      FeaturesManager.determine_framework(self.test_model	)






