



'''simple docstring'''

from __future__ import annotations

import unittest

import numpy as np

from transformers import OPTConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import GPTaTokenizer, TFOPTForCausalLM, TFOPTModel



def 					__lowerCamelCase					(				lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_=None						,      lowerCAmelCase_=None  )      ->				int:
		if attention_mask is None:
				_a					:				List[Any]				=							tf.cast(tf.math.not_equal(lowerCAmelCase_						,      config.pad_token_id  )						,      tf.inta  )
		return {"input_ids": input_ids, "attention_mask": attention_mask}

@require_tf
class      __magic_name__						:
							lowerCAmelCase	:   Tuple           = OPTConfig
							lowerCAmelCase	:   Dict           = {}
							lowerCAmelCase	:   str           = 'gelu'







							def __init__(							self :	Optional[Any]     ,_UpperCAmelCase :	int     ,_UpperCAmelCase :	str=13     ,_UpperCAmelCase :	Optional[Any]=7     ,_UpperCAmelCase :	List[Any]=True     ,_UpperCAmelCase :	Any=False     ,_UpperCAmelCase :	Dict=99     ,_UpperCAmelCase :	List[str]=16     ,_UpperCAmelCase :	List[Any]=2     ,_UpperCAmelCase :	str=4     ,_UpperCAmelCase :	Union[str, Any]=4     ,_UpperCAmelCase :	str="gelu"     ,_UpperCAmelCase :	List[str]=0.1     ,_UpperCAmelCase :	List[Any]=0.1     ,_UpperCAmelCase :	Optional[int]=20     ,_UpperCAmelCase :	str=2     ,_UpperCAmelCase :	Dict=1     ,_UpperCAmelCase :	int=0     ,_UpperCAmelCase :	Optional[int]=16     ,_UpperCAmelCase :	List[Any]=16     ,):
									_a					:				Dict				=							parent
									_a					:				Any				=							batch_size
									_a					:				str				=							seq_length
									_a					:				Optional[int]				=							is_training
									_a					:				Optional[int]				=							use_labels
									_a					:				Dict				=							vocab_size
									_a					:				List[Any]				=							hidden_size
									_a					:				str				=							num_hidden_layers
									_a					:				str				=							num_attention_heads
									_a					:				Optional[Any]				=							intermediate_size
									_a					:				Optional[int]				=							hidden_act
									_a					:				int				=							hidden_dropout_prob
									_a					:				Optional[Any]				=							attention_probs_dropout_prob
									_a					:				Optional[Any]				=							max_position_embeddings
									_a					:				Optional[Any]				=							eos_token_id
									_a					:				str				=							pad_token_id
									_a					:				int				=							bos_token_id
									_a					:				Dict				=							embed_dim
									_a					:				str				=							word_embed_proj_dim
									_a					:				int				=							False







							def 							__lowercase      (							self :	Any		):
									_a					:				Optional[int]				=							ids_tensor([self.batch_size, self.seq_length - 1]     ,self.vocab_size		)
									_a					:				List[Any]				=							tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size		)     ,1		)
									_a					:				List[Any]				=							tf.concat([input_ids, eos_tensor]     ,axis=1		)

									_a					:				Any				=							self.config_cls(
									    vocab_size=self.vocab_size     ,hidden_size=self.hidden_size     ,num_hidden_layers=self.num_hidden_layers     ,num_attention_heads=self.num_attention_heads     ,ffn_dim=self.intermediate_size     ,dropout=self.hidden_dropout_prob     ,attention_dropout=self.attention_probs_dropout_prob     ,max_position_embeddings=self.max_position_embeddings     ,eos_token_id=self.eos_token_id     ,bos_token_id=self.bos_token_id     ,pad_token_id=self.pad_token_id     ,embed_dim=self.embed_dim     ,word_embed_proj_dim=self.word_embed_proj_dim     ,is_encoder_decoder=_UpperCAmelCase     ,**self.config_updates     ,)
									_a					:				str				=							prepare_opt_inputs_dict(_UpperCAmelCase     ,_UpperCAmelCase		)
									return config, inputs_dict







							def 							__lowercase      (							self :	int     ,_UpperCAmelCase :	str     ,_UpperCAmelCase :	List[str]		):
									_a					:				Any				=							TFOPTModel(config=_UpperCAmelCase		)
									_a					:				Any				=							inputs_dict['input_ids']

									_a					:				Dict				=							input_ids[:1, :]
									_a					:				List[str]				=							inputs_dict['attention_mask'][:1, :]
									_a					:				Tuple				=							1

									# first forward pass
									_a					:				List[Any]				=							model(_UpperCAmelCase     ,attention_mask=_UpperCAmelCase     ,use_cache=_UpperCAmelCase		)

									_a					:				List[str]				=							outputs.to_tuple()

									# create hypothetical next token and extent to next_input_ids
									_a					:				int				=							ids_tensor((self.batch_size, 3)     ,config.vocab_size		)
									_a					:				List[Any]				=							tf.cast(ids_tensor((self.batch_size, 3)     ,2		)     ,tf.inta		)

									# append to next input_ids and
									_a					:				Tuple				=							tf.concat([input_ids, next_tokens]     ,axis=-1		)
									_a					:				Union[str, Any]				=							tf.concat([attention_mask, next_attn_mask]     ,axis=-1		)

									_a					:				Dict				=							model(_UpperCAmelCase     ,attention_mask=_UpperCAmelCase		)[0]
									_a					:				List[str]				=							model(_UpperCAmelCase     ,attention_mask=_UpperCAmelCase     ,past_key_values=_UpperCAmelCase		)[0]

									self.parent.assertEqual(next_tokens.shape[1]     ,output_from_past.shape[1]		)

									# select random slice
									_a					:				Union[str, Any]				=							int(ids_tensor((1,)     ,output_from_past.shape[-1]		)		)
									_a					:				List[str]				=							output_from_no_past[:, -3:, random_slice_idx]
									_a					:				List[str]				=							output_from_past[:, :, random_slice_idx]

									# test that outputs are equal for slice
									tf.debugging.assert_near(_UpperCAmelCase     ,_UpperCAmelCase     ,rtol=1E-3		)

@require_tf
class      __magic_name__						(   _UpperCamelCase      ,						_UpperCamelCase      ,						unittest.TestCase       ):
							lowerCAmelCase	:   Optional[int]           = (TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
							lowerCAmelCase	:   Optional[int]           = (TFOPTForCausalLM,) if is_tf_available() else ()
							lowerCAmelCase	:   List[str]           = (
							    {'feature-extraction': TFOPTModel, 'text-generation': TFOPTForCausalLM} if is_tf_available() else {}
							)
							lowerCAmelCase	:   List[Any]           = False
							lowerCAmelCase	:   str           = False
							lowerCAmelCase	:   List[str]           = False
							lowerCAmelCase	:   Dict           = 1_0







							def 							__lowercase      (							self :	Union[str, Any]		):
									_a					:				int				=							TFOPTModelTester(self		)
									_a					:				Dict				=							ConfigTester(self     ,config_class=_UpperCAmelCase		)







							def 							__lowercase      (							self :	Union[str, Any]		):
									self.config_tester.run_common_tests()







							def 							__lowercase      (							self :	int		):
									_a					:				Optional[Any]				=							self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.check_decoder_model_past_large_inputs(*_UpperCAmelCase		)







							def 							__lowercase      (							self :	Tuple		):
									_a					:				Any				=							self.model_tester.prepare_config_and_inputs_for_common()

									def _get_word_embedding_weight(_UpperCAmelCase :	Union[str, Any]     ,_UpperCAmelCase :	int		):
											if hasattr(_UpperCAmelCase     ,'weight'		):
													return embedding_layer.weight
											else:
													# Here we build the word embeddings weights if not exists.
													# And then we retry to get the attribute once built.
													model.build()
													if hasattr(_UpperCAmelCase     ,'weight'		):
															return embedding_layer.weight
													else:
															return None

									for model_class in self.all_model_classes:
											for size in [config.vocab_size - 10, config.vocab_size + 10]:
													# build the embeddings
													_a					:				Optional[int]				=							model_class(config=_UpperCAmelCase		)
													_a					:				Dict				=							_get_word_embedding_weight(_UpperCAmelCase     ,model.get_input_embeddings()		)
													_a					:				Optional[Any]				=							_get_word_embedding_weight(_UpperCAmelCase     ,model.get_output_embeddings()		)

													# reshape the embeddings
													model.resize_token_embeddings(_UpperCAmelCase		)
													_a					:				Union[str, Any]				=							_get_word_embedding_weight(_UpperCAmelCase     ,model.get_input_embeddings()		)
													_a					:				Optional[Any]				=							_get_word_embedding_weight(_UpperCAmelCase     ,model.get_output_embeddings()		)

													# check that the resized embeddings size matches the desired size.
													_a					:				Optional[int]				=							size if size is not None else config.vocab_size

													self.assertEqual(new_input_embeddings.shape[0]     ,_UpperCAmelCase		)

													# check that weights remain the same after resizing
													_a					:				Tuple				=							True
													for pa, pa in zip(old_input_embeddings.value()     ,new_input_embeddings.value()		):
															if tf.math.reduce_sum(tf.math.abs(pa - pa		)		) > 0:
																	_a					:				int				=							False
													self.assertTrue(_UpperCAmelCase		)

													if old_output_embeddings is not None and new_output_embeddings is not None:
															self.assertEqual(new_output_embeddings.shape[0]     ,_UpperCAmelCase		)

															_a					:				str				=							True
															for pa, pa in zip(old_output_embeddings.value()     ,new_output_embeddings.value()		):
																	if tf.math.reduce_sum(tf.math.abs(pa - pa		)		) > 0:
																			_a					:				List[str]				=							False
															self.assertTrue(_UpperCAmelCase		)



def 					__lowerCamelCase					(				lowerCAmelCase_  )      ->				Any:
		return tf.constant(lowerCAmelCase_						,      dtype=tf.intaa  )

@require_tf
class      __magic_name__						(   unittest.TestCase       ):
							lowerCAmelCase	:   Optional[Any]           = 9_9







							def 							__lowercase      (							self :	Union[str, Any]		):
									_a					:				Tuple				=							tf.ones((4, 1)     ,dtype=tf.intaa		) * 2
									_a					:				List[str]				=							tf.concat([ids_tensor((4, 6)     ,self.vocab_size - 3		) + 3, eos_column_vector]     ,axis=1		)
									_a					:				Any				=							input_ids.shape[0]
									_a					:				Optional[int]				=							OPTConfig(
									    vocab_size=self.vocab_size     ,hidden_size=24     ,num_hidden_layers=2     ,num_attention_heads=2     ,ffn_dim=32     ,max_position_embeddings=48     ,eos_token_id=2     ,pad_token_id=1     ,bos_token_id=0     ,)
									return config, input_ids, batch_size

@require_sentencepiece
@require_tf
class      __magic_name__						(   unittest.TestCase       ):







							@slow
							def 							__lowercase      (							self :	Optional[Any]		):
									_a					:				Any				=							TFOPTModel.from_pretrained('facebook/opt-350m'		)
									_a					:				Optional[Any]				=							_long_tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]		)
									_a					:				Any				=							tf.not_equal(_UpperCAmelCase     ,model.config.pad_token_id		)
									with tf.GradientTape():
											_a					:				Tuple				=							model(input_ids=_UpperCAmelCase     ,attention_mask=_UpperCAmelCase		).last_hidden_state
									_a					:				List[str]				=							(1, 11, 512)
									self.assertEqual(output.shape     ,_UpperCAmelCase		)
									_a					:				Dict				=							tf.constant(
									    [[-0.28_73, -1.92_18, -0.30_33], [-1.27_10, -0.13_38, -0.19_02], [0.40_95, 0.12_14, -1.31_21]]		)
									self.assertTrue(np.allclose(output[:, :3, :3]     ,_UpperCAmelCase     ,atol=4E-3		)		)

									_a					:				str				=							tf.function(_UpperCAmelCase     ,jit_compile=_UpperCAmelCase		)
									_a					:				Union[str, Any]				=							xla_generate(_UpperCAmelCase     ,_UpperCAmelCase		)[0]
									self.assertTrue(np.allclose(output[:, :3, :3]     ,_UpperCAmelCase     ,atol=4E-2		)		)

@require_tf
@slow
class      __magic_name__						(   unittest.TestCase       ):







							def 							__lowercase      (							self :	Union[str, Any]		):
									super().setUp()
									_a					:				List[str]				=							'facebook/opt-350m'







							def 							__lowercase      (							self :	Union[str, Any]		):
									_a					:				List[Any]				=							TFOPTForCausalLM.from_pretrained(self.path_model		)
									_a					:				Dict				=							GPTaTokenizer.from_pretrained(self.path_model		)

									_a					:				Optional[int]				=							[
									    'Today is a beautiful day and I want to',
									    'In the city of',
									    'Paris is the capital of France and',
									    'Computers and mobile phones have taken',
									]
									# verify that prompt without BOS token is identical to Metaseq -> add_special_tokens=False
									_a					:				List[str]				=							tokenizer(_UpperCAmelCase     ,return_tensors='tf'     ,padding=_UpperCAmelCase     ,add_special_tokens=_UpperCAmelCase		)
									_a					:				List[str]				=							tf.math.reduce_mean(model(inputs.input_ids     ,attention_mask=inputs.attention_mask		)[0]     ,axis=-1		)
									_a					:				str				=							tf.constant(
									    [
									        [1.38_51, -13.89_23, -10.52_29, -10.75_33, -0.23_09, -10.23_84, -0.53_65, -9.09_47, -5.16_70],
									        [-4.70_73, -10.62_76, -3.94_15, -21.52_42, -0.28_22, -0.28_22, -0.28_22, -0.28_22, -0.28_22],
									        [0.62_47, -3.42_29, -8.91_79, -1.42_97, -14.16_50, 1.41_46, -9.02_18, -0.27_03, -0.27_03],
									        [6.47_83, -1.99_13, -10.79_26, -2.33_36, 1.50_92, -0.99_74, -6.82_13, 1.34_77, 1.34_77],
									    ]		)
									self.assertTrue(np.allclose(_UpperCAmelCase     ,_UpperCAmelCase     ,atol=1E-4		)		)

									_a					:				Tuple				=							tf.function(_UpperCAmelCase     ,jit_compile=_UpperCAmelCase		)
									_a					:				List[Any]				=							tf.math.reduce_mean(xla_generate(inputs.input_ids     ,attention_mask=inputs.attention_mask		)[0]     ,axis=-1		)
									self.assertTrue(np.allclose(_UpperCAmelCase     ,_UpperCAmelCase     ,atol=1E-4		)		)

@require_tf
@slow
class      __magic_name__						(   unittest.TestCase       ):







							@property
							def 							__lowercase      (							self :	Tuple		):
									return [
									    "Today is a beautiful day and I want",
									    "In the city of",
									    "Paris is the capital of France and",
									    "Computers and mobile phones have taken",
									]







							def 							__lowercase      (							self :	List[Any]		):
									_a					:				Tuple				=							'facebook/opt-125m'

									_a					:				Union[str, Any]				=							[
									    'Today is a beautiful day and I want to',
									    'In the city of New York, the city',
									    'Paris is the capital of France and the capital',
									    'Computers and mobile phones have taken over the',
									]

									_a					:				Dict				=							[]
									_a					:				List[str]				=							GPTaTokenizer.from_pretrained(_UpperCAmelCase		)
									_a					:				Union[str, Any]				=							TFOPTForCausalLM.from_pretrained(_UpperCAmelCase		)

									for prompt in self.prompts:
											_a					:				str				=							tokenizer(_UpperCAmelCase     ,return_tensors='tf'		).input_ids

											_a					:				int				=							model.generate(_UpperCAmelCase     ,max_length=10		)

											_a					:				List[str]				=							tokenizer.batch_decode(_UpperCAmelCase     ,skip_special_tokens=_UpperCAmelCase		)
											predicted_outputs += generated_string

									self.assertListEqual(_UpperCAmelCase     ,_UpperCAmelCase		)







							def 							__lowercase      (							self :	List[Any]		):
									_a					:				Union[str, Any]				=							'facebook/opt-350m'

									_a					:				List[str]				=							GPTaTokenizer.from_pretrained(_UpperCAmelCase		)
									_a					:				List[Any]				=							TFOPTForCausalLM.from_pretrained(_UpperCAmelCase		)

									_a					:				List[Any]				=							'left'

									# use different length sentences to test batching
									_a					:				Union[str, Any]				=							[
									    'Hello, my dog is a little',
									    'Today, I',
									]

									_a					:				Tuple				=							tokenizer(_UpperCAmelCase     ,return_tensors='tf'     ,padding=_UpperCAmelCase		)
									_a					:				str				=							inputs['input_ids']

									_a					:				Dict				=							model.generate(input_ids=_UpperCAmelCase     ,attention_mask=inputs['attention_mask']		)

									_a					:				int				=							tokenizer(sentences[0]     ,return_tensors='tf'		).input_ids
									_a					:				Tuple				=							model.generate(input_ids=_UpperCAmelCase		)

									_a					:				List[Any]				=							inputs_non_padded.shape[-1] - tf.math.reduce_sum(
									    tf.cast(inputs['attention_mask'][-1]     ,tf.intaa		)		)
									_a					:				Any				=							tokenizer(sentences[1]     ,return_tensors='tf'		).input_ids
									_a					:				Optional[Any]				=							model.generate(input_ids=_UpperCAmelCase     ,max_length=model.config.max_length - num_paddings		)

									_a					:				int				=							tokenizer.batch_decode(_UpperCAmelCase     ,skip_special_tokens=_UpperCAmelCase		)
									_a					:				List[Any]				=							tokenizer.decode(output_non_padded[0]     ,skip_special_tokens=_UpperCAmelCase		)
									_a					:				Union[str, Any]				=							tokenizer.decode(output_padded[0]     ,skip_special_tokens=_UpperCAmelCase		)

									_a					:				Tuple				=							[
									    'Hello, my dog is a little bit of a dork.\nI\'m a little bit',
									    'Today, I was in the middle of a conversation with a friend about the',
									]
									self.assertListEqual(_UpperCAmelCase     ,_UpperCAmelCase		)
									self.assertListEqual(_UpperCAmelCase     ,[non_padded_sentence, padded_sentence]		)







							def 							__lowercase      (							self :	Dict		):
									_a					:				Tuple				=							'facebook/opt-350m'

									_a					:				Any				=							[
									    'Today is a beautiful day and I want to',
									    'In the city of San Francisco, the city',
									    'Paris is the capital of France and the capital',
									    'Computers and mobile phones have taken over the',
									]

									_a					:				List[str]				=							[]
									_a					:				Optional[Any]				=							GPTaTokenizer.from_pretrained(_UpperCAmelCase		)
									_a					:				List[str]				=							TFOPTForCausalLM.from_pretrained(_UpperCAmelCase		)

									for prompt in self.prompts:
											_a					:				Dict				=							tokenizer(_UpperCAmelCase     ,return_tensors='tf'		).input_ids

											_a					:				List[str]				=							model.generate(_UpperCAmelCase     ,max_length=10		)

											_a					:				Tuple				=							tokenizer.batch_decode(_UpperCAmelCase     ,skip_special_tokens=_UpperCAmelCase		)
											predicted_outputs += generated_string

									self.assertListEqual(_UpperCAmelCase     ,_UpperCAmelCase		)









'''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()




