
import argparse
import os

import numpy as np
import tensorflow as tf
import torch

from transformers import BertModel




def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	BertModel		,   SCREAMING_SNAKE_CASE_	:	str		,   SCREAMING_SNAKE_CASE_	:	str       )  ->     Dict:
						_lowercase					       =					("""dense.weight""", """attention.self.query""", """attention.self.key""", """attention.self.value""")

						_lowercase					       =					(
						    ("""layer.""", """layer_"""),
						    ("""word_embeddings.weight""", """word_embeddings"""),
						    ("""position_embeddings.weight""", """position_embeddings"""),
						    ("""token_type_embeddings.weight""", """token_type_embeddings"""),
						    (""".""", """/"""),
						    ("""LayerNorm/weight""", """LayerNorm/gamma"""),
						    ("""LayerNorm/bias""", """LayerNorm/beta"""),
						    ("""weight""", """kernel"""),
						)

						if not os.path.isdir(snake_case__       ):
												os.makedirs(snake_case__       )

						_lowercase					       =					model.state_dict()

						def to_tf_var_name(SCREAMING_SNAKE_CASE_	:	str       ):
												for patt, repl in iter(snake_case__       ):
																		_lowercase					       =					name.replace(snake_case__		,   snake_case__       )
												return f"""bert/{name}"""

						def create_tf_var(SCREAMING_SNAKE_CASE_	:	np.ndarray		,   SCREAMING_SNAKE_CASE_	:	str		,   SCREAMING_SNAKE_CASE_	:	tf.Session       ):
												_lowercase					       =					tf.dtypes.as_dtype(tensor.dtype       )
												_lowercase					       =					tf.get_variable(dtype=snake_case__		,   shape=tensor.shape		,   name=snake_case__		,   initializer=tf.zeros_initializer()       )
												session.run(tf.variables_initializer([tf_var]       )       )
												session.run(snake_case__       )
												return tf_var

						tf.reset_default_graph()
						with tf.Session() as session:
												for var_name in state_dict:
																		_lowercase					       =					to_tf_var_name(snake_case__       )
																		_lowercase					       =					state_dict[var_name].numpy()
																		if any(x in var_name for x in tensors_to_transpose       ):
																								_lowercase					       =					torch_tensor.T
																		_lowercase					       =					create_tf_var(tensor=snake_case__		,   name=snake_case__		,   session=snake_case__       )
																		tf.keras.backend.set_value(snake_case__		,   snake_case__       )
																		_lowercase					       =					session.run(snake_case__       )
																		print(f"""Successfully created {tf_name}: {np.allclose(snake_case__		,   snake_case__       )}"""       )

												_lowercase					       =					tf.train.Saver(tf.trainable_variables()       )
												saver.save(snake_case__		,   os.path.join(snake_case__		,   model_name.replace("""-"""		,   """_"""       ) + """.ckpt"""       )       )




def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	Tuple=None       )  ->     Optional[int]:
						_lowercase					       =					argparse.ArgumentParser()
						parser.add_argument("""--model_name"""		,   type=snake_case__		,   required=snake_case__		,   help="""model name e.g. bert-base-uncased"""       )
						parser.add_argument(
						    """--cache_dir"""		,   type=snake_case__		,   default=snake_case__		,   required=snake_case__		,   help="""Directory containing pytorch model"""       )
						parser.add_argument("""--pytorch_model_path"""		,   type=snake_case__		,   required=snake_case__		,   help="""/path/to/<pytorch-model-name>.bin"""       )
						parser.add_argument("""--tf_cache_dir"""		,   type=snake_case__		,   required=snake_case__		,   help="""Directory in which to save tensorflow model"""       )
						_lowercase					       =					parser.parse_args(snake_case__       )

						_lowercase					       =					BertModel.from_pretrained(
						    pretrained_model_name_or_path=args.model_name		,   state_dict=torch.load(args.pytorch_model_path       )		,   cache_dir=args.cache_dir		,   )

						convert_pytorch_checkpoint_to_tf(model=snake_case__		,   ckpt_dir=args.tf_cache_dir		,   model_name=args.model_name       )


if __name__ == "__main__":
		main()

"""simple docstring"""


from maths.prime_check import is_prime






def    _snake_case					(		snake_case__ :  int  ):
	if not isinstance(snake_case__						,   snake_case__  ):
		A     = F'Input value of [number={number}] must be an integer'
		raise TypeError(snake_case__  )
	if is_prime(snake_case__  ) and is_prime(number + 2  ):
		return number + 2
	else:
		return -1


if __name__ == "__main__":
		import doctest

		doctest.testmod()