



'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__lowerCAmelCase						      =       {
    '''configuration_data2vec_audio''': ['''DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Data2VecAudioConfig'''],
    '''configuration_data2vec_text''': [
        '''DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Data2VecTextConfig''',
        '''Data2VecTextOnnxConfig''',
    ],
    '''configuration_data2vec_vision''': [
        '''DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Data2VecVisionConfig''',
        '''Data2VecVisionOnnxConfig''',
    ],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase						      =       [
							    '''DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''Data2VecAudioForAudioFrameClassification''',
							    '''Data2VecAudioForCTC''',
							    '''Data2VecAudioForSequenceClassification''',
							    '''Data2VecAudioForXVector''',
							    '''Data2VecAudioModel''',
							    '''Data2VecAudioPreTrainedModel''',
							]
							__lowerCAmelCase						      =       [
							    '''DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''Data2VecTextForCausalLM''',
							    '''Data2VecTextForMaskedLM''',
							    '''Data2VecTextForMultipleChoice''',
							    '''Data2VecTextForQuestionAnswering''',
							    '''Data2VecTextForSequenceClassification''',
							    '''Data2VecTextForTokenClassification''',
							    '''Data2VecTextModel''',
							    '''Data2VecTextPreTrainedModel''',
							]
							__lowerCAmelCase						      =       [
							    '''DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''Data2VecVisionForImageClassification''',
							    '''Data2VecVisionForMaskedImageModeling''',
							    '''Data2VecVisionForSemanticSegmentation''',
							    '''Data2VecVisionModel''',
							    '''Data2VecVisionPreTrainedModel''',
							]

if is_tf_available():
							__lowerCAmelCase						      =       [
							    '''TFData2VecVisionForImageClassification''',
							    '''TFData2VecVisionForSemanticSegmentation''',
							    '''TFData2VecVisionModel''',
							    '''TFData2VecVisionPreTrainedModel''',
							]

if TYPE_CHECKING:
							from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
							from .configuration_dataavec_text import (
							    DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    DataaVecTextConfig,
							    DataaVecTextOnnxConfig,
							)
							from .configuration_dataavec_vision import (
							    DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    DataaVecVisionConfig,
							    DataaVecVisionOnnxConfig,
							)

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_dataavec_audio import (
														    DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
														    DataaVecAudioForAudioFrameClassification,
														    DataaVecAudioForCTC,
														    DataaVecAudioForSequenceClassification,
														    DataaVecAudioForXVector,
														    DataaVecAudioModel,
														    DataaVecAudioPreTrainedModel,
														)
														from .modeling_dataavec_text import (
														    DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    DataaVecTextForCausalLM,
														    DataaVecTextForMaskedLM,
														    DataaVecTextForMultipleChoice,
														    DataaVecTextForQuestionAnswering,
														    DataaVecTextForSequenceClassification,
														    DataaVecTextForTokenClassification,
														    DataaVecTextModel,
														    DataaVecTextPreTrainedModel,
														)
														from .modeling_dataavec_vision import (
														    DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
														    DataaVecVisionForImageClassification,
														    DataaVecVisionForMaskedImageModeling,
														    DataaVecVisionForSemanticSegmentation,
														    DataaVecVisionModel,
														    DataaVecVisionPreTrainedModel,
														)
							if is_tf_available():
														from .modeling_tf_dataavec_vision import (
														    TFDataaVecVisionForImageClassification,
														    TFDataaVecVisionForSemanticSegmentation,
														    TFDataaVecVisionModel,
														    TFDataaVecVisionPreTrainedModel,
														)

else:
							import sys

							__lowerCAmelCase						      =       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)









'''simple docstring'''

import os
import random
import sys

from . import cryptomath_module as cryptomath
from . import rabin_miller

__lowerCAmelCase						      =       3



def 					__lowerCamelCase					(				lowerCAmelCase_  )      ->				int:
		print('Generating primitive root of p'  )
		while True:
				_a					:				List[Any]				=							random.randrange(3						,      lowerCAmelCase_  )
				if pow(lowerCAmelCase_						,      2						,      lowerCAmelCase_  ) == 1:
						continue
				if pow(lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_  ) == 1:
						continue
				return g



def 					__lowerCamelCase					(				lowerCAmelCase_  )      ->				tuple[tuple[int, int, int, int], tuple[int, int]]:
		print('Generating prime p...'  )
		_a					:				int				=							rabin_miller.generate_large_prime(lowerCAmelCase_  )  # select large prime number.
		_a					:				List[str]				=							primitive_root(lowerCAmelCase_  )  # one primitive root on modulo p.
		_a					:				Any				=							random.randrange(3						,      lowerCAmelCase_  )  # private_key -> have to be greater than 2 for safety.
		_a					:				List[Any]				=							cryptomath.find_mod_inverse(pow(lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_  )						,      lowerCAmelCase_  )

		_a					:				Tuple				=							(key_size, e_a, e_a, p)
		_a					:				str				=							(key_size, d)

		return public_key, private_key



def 					__lowerCamelCase					(				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					:				Dict				=							generate_key(lowerCAmelCase_  )
		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 					__lowerCamelCase					(				)      ->				None:
		print('Making key files...'  )
		make_key_files('elgamal'						,      2048  )
		print('Key files generation successful'  )


if __name__ == "__main__":
							main()




