






'''simple docstring'''







from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
			import numpy as np
			import tensorflow as tf

			from transformers import (
			    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
			    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
			    TF_MODEL_FOR_MASKED_LM_MAPPING,
			    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
			    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
			    TF_MODEL_FOR_PRETRAINING_MAPPING,
			    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
			    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
			    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
			    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
			    TFSharedEmbeddings,
			)

			if _tf_gpu_memory_limit is not None:
						_A      :     Optional[Any]       	=tf.config.list_physical_devices('''GPU''')
						for gpu in gpus:
									# Restrict TensorFlow to only allocate x GB of memory on the GPUs
									try:
												tf.config.set_logical_device_configuration(
												    gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
												)
												_A      :     Dict       	=tf.config.list_logical_devices('''GPU''')
												print('''Logical GPUs''', logical_gpus)
									except RuntimeError as e:
												# Virtual devices must be set before GPUs have been initialized
												print(e)

@require_tf
class _lowercase      :
							a							 =			None
							a							 =			()
							a							 =			()
							a							 =			True
							a							 =			True
							a							 =			True
							a							 =			False




							def 						lowerCamelCase_							(				self:							int     ,				UpperCamelCase__:							Tuple     ,				UpperCamelCase__:							Union[str, Any]     ,				UpperCamelCase__:							Dict=False	):
														lowerCamelCase__   :      Union[str, Any]			    =			copy.deepcopy(UpperCamelCase__	)

														if model_class in get_values(UpperCamelCase__	):
																					lowerCamelCase__   :      str			    =			{
																					    k: tf.tile(tf.expand_dims(UpperCamelCase__     ,				1	)     ,				(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)	)
																					    if isinstance(UpperCamelCase__     ,				tf.Tensor	) and v.ndim > 0
																					    else v
																					    for k, v in inputs_dict.items()
																					}

														if return_labels:
																					if model_class in get_values(UpperCamelCase__	):
																												lowerCamelCase__   :      Union[str, Any]			    =			tf.ones(self.model_tester.batch_size     ,				dtype=tf.intaa	)
																					elif model_class in get_values(UpperCamelCase__	):
																												lowerCamelCase__   :      Dict			    =			tf.zeros(self.model_tester.batch_size     ,				dtype=tf.intaa	)
																												lowerCamelCase__   :      Tuple			    =			tf.zeros(self.model_tester.batch_size     ,				dtype=tf.intaa	)
																					elif model_class in [
																					    *get_values(UpperCamelCase__	),
																					    *get_values(UpperCamelCase__	),
																					]:
																												lowerCamelCase__   :      List[Any]			    =			tf.zeros(self.model_tester.batch_size     ,				dtype=tf.intaa	)
																					elif model_class in get_values(UpperCamelCase__	):
																												lowerCamelCase__   :      Union[str, Any]			    =			tf.zeros(self.model_tester.batch_size     ,				dtype=tf.intaa	)
																					elif model_class in [
																					    *get_values(UpperCamelCase__	),
																					    *get_values(UpperCamelCase__	),
																					    *get_values(UpperCamelCase__	),
																					    *get_values(UpperCamelCase__	),
																					    *get_values(UpperCamelCase__	),
																					]:
																												lowerCamelCase__   :      str			    =			tf.zeros(
																												    (self.model_tester.batch_size, self.model_tester.seq_length)     ,				dtype=tf.intaa	)
														return inputs_dict




							@slow
							def 						lowerCamelCase_							(				self:							int	):
														lowerCamelCase__    ,						lowerCamelCase__   :      Optional[int]			    =			self.model_tester.prepare_config_and_inputs_for_common()
														for model_class in self.all_model_classes[:2]:
																					lowerCamelCase__   :      Union[str, Any]			    =			self._prepare_for_class(UpperCamelCase__     ,				UpperCamelCase__	)
																					lowerCamelCase__   :      Union[str, Any]			    =			model_class(UpperCamelCase__	)

																					@tf.function
																					def run_in_graph_mode():
																												return model(UpperCamelCase__	)

																					lowerCamelCase__   :      Optional[int]			    =			run_in_graph_mode()
																					self.assertIsNotNone(UpperCamelCase__	)




							@slow
							def 						lowerCamelCase_							(				self:							Dict	):
														lowerCamelCase__    ,						lowerCamelCase__   :      Optional[Any]			    =			self.model_tester.prepare_config_and_inputs_for_common()
														for model_class in self.all_model_classes[:2]:
																					lowerCamelCase__   :      str			    =			self._prepare_for_class(UpperCamelCase__     ,				UpperCamelCase__	)
																					lowerCamelCase__   :      Optional[int]			    =			model_class(UpperCamelCase__	)

																					@tf.function(experimental_compile=UpperCamelCase__	)
																					def run_in_graph_mode():
																												return model(UpperCamelCase__	)

																					lowerCamelCase__   :      str			    =			run_in_graph_mode()
																					self.assertIsNotNone(UpperCamelCase__	)




							@slow
							def 						lowerCamelCase_							(				self:							int	):
														# This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
														lowerCamelCase__    ,						lowerCamelCase__   :      Tuple			    =			self.model_tester.prepare_config_and_inputs_for_common()
														for model_class in self.all_model_classes[:2]:
																					lowerCamelCase__   :      List[Any]			    =			model_class(UpperCamelCase__	)
																					if getattr(UpperCamelCase__     ,				"""hf_compute_loss"""     ,				UpperCamelCase__	):
																												# Test that model correctly compute the loss with kwargs
																												lowerCamelCase__   :      str			    =			self._prepare_for_class(inputs_dict.copy()     ,				UpperCamelCase__     ,				return_labels=UpperCamelCase__	)
																												# Is there a better way to remove these decoder inputs?
																												lowerCamelCase__   :      List[Any]			    =			{
																												    key: val
																												    for key, val in prepared_for_class.items()
																												    if key not in ("""head_mask""", """decoder_head_mask""", """cross_attn_head_mask""", """decoder_input_ids""")
																												}

																												lowerCamelCase__   :      Optional[int]			    =			{
																												    """labels""",
																												    """label""",
																												    """label_ids""",
																												    """start_positions""",
																												    """start_position""",
																												    """end_positions""",
																												    """end_position""",
																												    """next_sentence_label""",
																												}
																												lowerCamelCase__   :      Dict			    =			possible_label_cols.intersection(set(UpperCamelCase__	)	)
																												self.assertGreater(len(UpperCamelCase__	)     ,				0     ,				msg="""No matching label names found!"""	)
																												lowerCamelCase__   :      Union[str, Any]			    =			{key: val for key, val in prepared_for_class.items() if key in label_names}
																												lowerCamelCase__   :      Tuple			    =			{key: val for key, val in prepared_for_class.items() if key not in label_names}
																												self.assertGreater(len(UpperCamelCase__	)     ,				0	)

																												# Make sure it works with XLA!
																												model.compile(optimizer=tf.keras.optimizers.SGD(0.0	)     ,				jit_compile=UpperCamelCase__	)
																												# Make sure the model fits without crashing regardless of where we pass the labels
																												lowerCamelCase__   :      Dict			    =			model.fit(
																												    UpperCamelCase__     ,				validation_data=UpperCamelCase__     ,				steps_per_epoch=1     ,				validation_steps=1     ,				shuffle=UpperCamelCase__     ,				verbose=0     ,				)
																												lowerCamelCase__   :      Dict			    =			history.history["""loss"""][0]
																												self.assertTrue(not isnan(UpperCamelCase__	)	)
																												lowerCamelCase__   :      List[Any]			    =			history.history["""val_loss"""][0]
																												self.assertTrue(not isnan(UpperCamelCase__	)	)

																												# Now test it with separate labels, to make sure that path works in XLA too.
																												lowerCamelCase__   :      Union[str, Any]			    =			model_class(UpperCamelCase__	)
																												model.compile(optimizer=tf.keras.optimizers.SGD(0.0	)     ,				jit_compile=UpperCamelCase__	)
																												lowerCamelCase__   :      int			    =			model.fit(
																												    UpperCamelCase__     ,				UpperCamelCase__     ,				validation_data=(inputs_minus_labels, labels)     ,				steps_per_epoch=1     ,				validation_steps=1     ,				shuffle=UpperCamelCase__     ,				verbose=0     ,				)

																												lowerCamelCase__   :      int			    =			history.history["""loss"""][0]
																												self.assertTrue(not isnan(UpperCamelCase__	)	)
																												lowerCamelCase__   :      Tuple			    =			history.history["""val_loss"""][0]
																												self.assertTrue(not isnan(UpperCamelCase__	)	)




							@slow
							def 						lowerCamelCase_							(				self:							Optional[int]	):
														lowerCamelCase__    ,						lowerCamelCase__   :      int			    =			self.model_tester.prepare_config_and_inputs_for_common()
														lowerCamelCase__   :      List[Any]			    =			True
														lowerCamelCase__   :      Dict			    =			True

														if hasattr(UpperCamelCase__     ,				"""use_cache"""	):
																					lowerCamelCase__   :      List[str]			    =			True

														lowerCamelCase__   :      Optional[int]			    =			getattr(self.model_tester     ,				"""encoder_seq_length"""     ,				self.model_tester.seq_length	)
														lowerCamelCase__   :      Union[str, Any]			    =			getattr(self.model_tester     ,				"""key_length"""     ,				UpperCamelCase__	)

														for model_class in self.all_model_classes[:2]:
																					lowerCamelCase__   :      List[str]			    =			self._prepare_for_class(UpperCamelCase__     ,				UpperCamelCase__	)
																					lowerCamelCase__   :      Optional[Any]			    =			model_class(UpperCamelCase__	)
																					model.build()
																					lowerCamelCase__   :      int			    =			len(model(UpperCamelCase__	)	)

																					for key in list(class_inputs_dict.keys()	):
																												# Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
																												if key not in model.input_signature:
																																			del class_inputs_dict[key]
																												# Check it's a tensor, in case the inputs dict has some bools in it too
																												elif isinstance(class_inputs_dict[key]     ,				tf.Tensor	) and class_inputs_dict[key].dtype.is_integer:
																																			lowerCamelCase__   :      Dict			    =			tf.cast(class_inputs_dict[key]     ,				tf.intaa	)

																					if set(class_inputs_dict.keys()	) != set(model.input_signature.keys()	):
																												continue  # Some models have inputs that the preparation functions don't create, we skip those

																					with tempfile.TemporaryDirectory() as tmpdirname:
																												model.save_pretrained(UpperCamelCase__     ,				saved_model=UpperCamelCase__	)
																												lowerCamelCase__   :      Optional[Any]			    =			os.path.join(UpperCamelCase__     ,				"""saved_model"""     ,				"""1"""	)
																												lowerCamelCase__   :      str			    =			tf.keras.models.load_model(UpperCamelCase__	)
																												lowerCamelCase__   :      Optional[Any]			    =			model(UpperCamelCase__	)

																												if self.is_encoder_decoder:
																																			lowerCamelCase__   :      Union[str, Any]			    =			outputs["""encoder_hidden_states"""]
																																			lowerCamelCase__   :      Union[str, Any]			    =			outputs["""encoder_attentions"""]
																												else:
																																			lowerCamelCase__   :      Dict			    =			outputs["""hidden_states"""]
																																			lowerCamelCase__   :      Union[str, Any]			    =			outputs["""attentions"""]

																												self.assertEqual(len(UpperCamelCase__	)     ,				UpperCamelCase__	)

																												lowerCamelCase__   :      str			    =			getattr(
																												    self.model_tester     ,				"""expected_num_hidden_layers"""     ,				self.model_tester.num_hidden_layers + 1	)

																												self.assertEqual(len(UpperCamelCase__	)     ,				UpperCamelCase__	)
																												self.assertListEqual(
																												    list(output_hidden_states[0].shape[-2:]	)     ,				[self.model_tester.seq_length, self.model_tester.hidden_size]     ,				)

																												self.assertEqual(len(UpperCamelCase__	)     ,				self.model_tester.num_hidden_layers	)
																												self.assertListEqual(
																												    list(output_attentions[0].shape[-3:]	)     ,				[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]     ,				)




							@slow
							def 						lowerCamelCase_							(				self:							Dict	):
														tf.keras.mixed_precision.set_global_policy("""mixed_float16"""	)

														# try/finally block to ensure subsequent tests run in float32
														try:
																					lowerCamelCase__    ,						lowerCamelCase__   :      Optional[Any]			    =			self.model_tester.prepare_config_and_inputs_for_common()
																					for model_class in self.all_model_classes[:2]:
																												lowerCamelCase__   :      int			    =			self._prepare_for_class(UpperCamelCase__     ,				UpperCamelCase__	)
																												lowerCamelCase__   :      Optional[int]			    =			model_class(UpperCamelCase__	)
																												lowerCamelCase__   :      Optional[Any]			    =			model(UpperCamelCase__	)

																												self.assertIsNotNone(UpperCamelCase__	)
														finally:
																					tf.keras.mixed_precision.set_global_policy("""float32"""	)




							@slow
							def 						lowerCamelCase_							(				self:							List[str]	):
														lowerCamelCase__    ,						lowerCamelCase__   :      Optional[int]			    =			self.model_tester.prepare_config_and_inputs_for_common()
														# head_mask and decoder_head_mask has different shapes than other input args
														if "head_mask" in inputs_dict:
																					del inputs_dict["head_mask"]
														if "decoder_head_mask" in inputs_dict:
																					del inputs_dict["decoder_head_mask"]
														if "cross_attn_head_mask" in inputs_dict:
																					del inputs_dict["cross_attn_head_mask"]
														lowerCamelCase__   :      Union[str, Any]			    =			{
														    module_member
														    for model_class in self.all_model_classes
														    for module in (import_module(model_class.__module__	),)
														    for module_member_name in dir(UpperCamelCase__	)
														    if module_member_name.endswith("""MainLayer"""	)
														    for module_member in (getattr(UpperCamelCase__     ,				UpperCamelCase__	),)
														    if isinstance(UpperCamelCase__     ,				UpperCamelCase__	)
														    and tf.keras.layers.Layer in module_member.__bases__
														    and getattr(UpperCamelCase__     ,				"""_keras_serializable"""     ,				UpperCamelCase__	)
														}

														for main_layer_class in tf_main_layer_classes:
																					# T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
																					if "T5" in main_layer_class.__name__:
																												# Take the same values than in TFT5ModelTester for this shared layer
																												lowerCamelCase__   :      List[Any]			    =			TFSharedEmbeddings(self.model_tester.vocab_size     ,				self.model_tester.hidden_size     ,				name="""shared"""	)
																												lowerCamelCase__   :      int			    =			False
																												lowerCamelCase__   :      int			    =			main_layer_class(UpperCamelCase__     ,				embed_tokens=UpperCamelCase__	)
																					else:
																												lowerCamelCase__   :      Optional[int]			    =			main_layer_class(UpperCamelCase__	)

																					lowerCamelCase__   :      Optional[Any]			    =			{
																					    name: tf.keras.Input(tensor.shape[1:]     ,				dtype=tensor.dtype	) for name, tensor in inputs_dict.items()
																					}

																					if hasattr(self.model_tester     ,				"""num_labels"""	):
																												lowerCamelCase__   :      Any			    =			self.model_tester.num_labels
																					else:
																												lowerCamelCase__   :      int			    =			2

																					lowerCamelCase__   :      List[Any]			    =			tf.data.Dataset.from_tensor_slices(
																					    (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)	))	).batch(1	)

																					lowerCamelCase__   :      List[Any]			    =			main_layer(UpperCamelCase__	)[0]
																					lowerCamelCase__   :      Any			    =			tf.keras.layers.Dense(UpperCamelCase__     ,				activation="""softmax"""     ,				name="""outputs"""	)(UpperCamelCase__	)
																					lowerCamelCase__   :      str			    =			tf.keras.models.Model(inputs=UpperCamelCase__     ,				outputs=[outputs]	)

																					model.compile(loss="""binary_crossentropy"""     ,				optimizer="""adam"""     ,				metrics=["""binary_accuracy"""]	)
																					model.fit(UpperCamelCase__     ,				epochs=1	)

																					with tempfile.TemporaryDirectory() as tmpdirname:
																												lowerCamelCase__   :      List[Any]			    =			os.path.join(UpperCamelCase__     ,				"""keras_model.h5"""	)
																												model.save(UpperCamelCase__	)
																												if "T5" in main_layer_class.__name__:
																																			lowerCamelCase__   :      List[Any]			    =			tf.keras.models.load_model(
																																			    UpperCamelCase__     ,				custom_objects={
																																			        main_layer_class.__name__: main_layer_class,
																																			        """TFSharedEmbeddings""": TFSharedEmbeddings,
																																			    }     ,				)
																												else:
																																			lowerCamelCase__   :      Dict			    =			tf.keras.models.load_model(
																																			    UpperCamelCase__     ,				custom_objects={main_layer_class.__name__: main_layer_class}	)
																												assert isinstance(UpperCamelCase__     ,				tf.keras.Model	)
																												model(UpperCamelCase__	)




							@slow
							def 						lowerCamelCase_							(				self:							List[Any]	):
														lowerCamelCase__    ,						lowerCamelCase__   :      List[Any]			    =			self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes[:2]:
																					lowerCamelCase__   :      List[str]			    =			model_class(UpperCamelCase__	)

																					lowerCamelCase__   :      int			    =			copy.deepcopy(UpperCamelCase__	)

																					if not self.is_encoder_decoder:
																												lowerCamelCase__   :      List[Any]			    =			inputs["""input_ids"""]
																												del inputs["input_ids"]
																					else:
																												lowerCamelCase__   :      List[str]			    =			inputs["""input_ids"""]
																												lowerCamelCase__   :      Optional[Any]			    =			inputs.get("""decoder_input_ids"""     ,				UpperCamelCase__	)
																												del inputs["input_ids"]
																												inputs.pop("""decoder_input_ids"""     ,				UpperCamelCase__	)

																					if not self.is_encoder_decoder:
																												lowerCamelCase__   :      List[Any]			    =			model.get_input_embeddings()(UpperCamelCase__	)
																					else:
																												lowerCamelCase__   :      int			    =			model.get_input_embeddings()(UpperCamelCase__	)
																												lowerCamelCase__   :      List[Any]			    =			model.get_input_embeddings()(UpperCamelCase__	)

																					lowerCamelCase__   :      Tuple			    =			self._prepare_for_class(UpperCamelCase__     ,				UpperCamelCase__	)

																					@tf.function
																					def run_in_graph_mode():
																												return model(UpperCamelCase__	)

																					lowerCamelCase__   :      Union[str, Any]			    =			run_in_graph_mode()
																					self.assertIsNotNone(UpperCamelCase__	)




							def 						lowerCamelCase_							(				self:							Tuple     ,				UpperCamelCase__:							Any     ,				UpperCamelCase__:							Optional[Any]	):
														# special tokens cannot be bad tokens
														lowerCamelCase__   :      List[str]			    =			[]
														if model.config.bos_token_id is not None:
																					special_tokens.append(model.config.bos_token_id	)
														if model.config.pad_token_id is not None:
																					special_tokens.append(model.config.pad_token_id	)
														if model.config.eos_token_id is not None:
																					special_tokens.append(model.config.eos_token_id	)

														# create random bad tokens that are not special tokens
														lowerCamelCase__   :      List[Any]			    =			[]
														while len(UpperCamelCase__	) < num_bad_tokens:
																					lowerCamelCase__   :      List[str]			    =			tf.squeeze(ids_tensor((1, 1)     ,				self.model_tester.vocab_size	)     ,				0	).numpy()[0]
																					if token not in special_tokens:
																												bad_tokens.append(UpperCamelCase__	)
														return bad_tokens




							def 						lowerCamelCase_							(				self:							Union[str, Any]     ,				UpperCamelCase__:							List[Any]	):
														for token_id in output_ids[0].numpy().tolist():
																					self.assertGreaterEqual(UpperCamelCase__     ,				0	)
																					self.assertLess(UpperCamelCase__     ,				self.model_tester.vocab_size	)




							def 						lowerCamelCase_							(				self:							Dict     ,				UpperCamelCase__:							List[Any]     ,				UpperCamelCase__:							int	):
														# for all bad word tokens
														for bad_word_ids in bad_words_ids:
																					# for all slices in batch
																					for generated_ids_slice in generated_ids:
																												# for all word idx
																												for i in range(len(UpperCamelCase__	)     ,				len(UpperCamelCase__	)	):
																																			# if tokens match
																																			if generated_ids_slice[i - len(UpperCamelCase__	) : i] == bad_word_ids:
																																										return True
														return False









'''simple docstring'''







def 					SCREAMING_SNAKE_CASE_			(UpperCamelCase							,     UpperCamelCase = 13 ) ->			str:
							lowerCamelCase__   :      Dict			    =			""""""
							for c in s:
														if "A" <= c <= "Z":
																					out += chr(ord("""A""" ) + (ord(UpperCamelCase ) - ord("""A""" ) + n) % 26 )
														elif "a" <= c <= "z":
																					out += chr(ord("""a""" ) + (ord(UpperCamelCase ) - ord("""a""" ) + n) % 26 )
														else:
																					out += c
							return out





def 					SCREAMING_SNAKE_CASE_			() ->			None:
							lowerCamelCase__   :      Dict			    =			input("""Enter message: """ )

							lowerCamelCase__   :      str			    =			dencrypt(UpperCamelCase							,     13 )
							print("""Encryption:"""							,     UpperCamelCase )

							lowerCamelCase__   :      List[str]			    =			dencrypt(UpperCamelCase							,     13 )
							print("""Decryption: """							,     UpperCamelCase )


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			main()

