





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      A__       (    SCREAMING_SNAKE_CASE_   :      Optional[int]				,	SCREAMING_SNAKE_CASE_   :      Optional[Any]				,	SCREAMING_SNAKE_CASE_   :      Dict=None				,	SCREAMING_SNAKE_CASE_   :      str=None						)  ->  str:






   """simple docstring"""







   if attention_mask is None:
      _UpperCAmelCase           =   tf.cast(tf.math.not_equal(SCREAMING_SNAKE_CASE_				,	config.pad_token_id						)				,	tf.inta						)
   return {"input_ids": input_ids, "attention_mask": attention_mask}




@require_tf
class 			__UpperCamelCase    :
     __A	:  Optional[int]							  =   OPTConfig
     __A	:  Tuple							  =   {}
     __A	:  List[Any]							  =   """gelu"""





     def __init__(     self				,							_UpperCamelCase				,							_UpperCamelCase=13				,							_UpperCamelCase=7				,							_UpperCamelCase=True				,							_UpperCamelCase=False				,							_UpperCamelCase=99				,							_UpperCamelCase=16				,							_UpperCamelCase=2				,							_UpperCamelCase=4				,							_UpperCamelCase=4				,							_UpperCamelCase="gelu"				,							_UpperCamelCase=0.1				,							_UpperCamelCase=0.1				,							_UpperCamelCase=20				,							_UpperCamelCase=2				,							_UpperCamelCase=1				,							_UpperCamelCase=0				,							_UpperCamelCase=16				,							_UpperCamelCase=16				,							):
        _UpperCAmelCase           =   parent
        _UpperCAmelCase           =   batch_size
        _UpperCAmelCase           =   seq_length
        _UpperCAmelCase           =   is_training
        _UpperCAmelCase           =   use_labels
        _UpperCAmelCase           =   vocab_size
        _UpperCAmelCase           =   hidden_size
        _UpperCAmelCase           =   num_hidden_layers
        _UpperCAmelCase           =   num_attention_heads
        _UpperCAmelCase           =   intermediate_size
        _UpperCAmelCase           =   hidden_act
        _UpperCAmelCase           =   hidden_dropout_prob
        _UpperCAmelCase           =   attention_probs_dropout_prob
        _UpperCAmelCase           =   max_position_embeddings
        _UpperCAmelCase           =   eos_token_id
        _UpperCAmelCase           =   pad_token_id
        _UpperCAmelCase           =   bos_token_id
        _UpperCAmelCase           =   embed_dim
        _UpperCAmelCase           =   word_embed_proj_dim
        _UpperCAmelCase           =   False





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   ids_tensor([self.batch_size, self.seq_length - 1]				,							self.vocab_size					)
        _UpperCAmelCase           =   tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size					)				,							1					)
        _UpperCAmelCase           =   tf.concat([input_ids, eos_tensor]				,							axis=1					)

        _UpperCAmelCase           =   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				,							)
        _UpperCAmelCase           =   prepare_opt_inputs_dict(_UpperCamelCase				,							_UpperCamelCase					)
        return config, inputs_dict





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase					):
        _UpperCAmelCase           =   TFOPTModel(config=_UpperCamelCase					)
        _UpperCAmelCase           =   inputs_dict['''input_ids''']

        _UpperCAmelCase           =   input_ids[:1, :]
        _UpperCAmelCase           =   inputs_dict['''attention_mask'''][:1, :]
        _UpperCAmelCase           =   1

        # first forward pass
        _UpperCAmelCase           =   model(_UpperCamelCase				,							attention_mask=_UpperCamelCase				,							use_cache=_UpperCamelCase					)

        _UpperCAmelCase       ,      _UpperCAmelCase           =   outputs.to_tuple()

        # create hypothetical next token and extent to next_input_ids
        _UpperCAmelCase           =   ids_tensor((self.batch_size, 3)				,							config.vocab_size					)
        _UpperCAmelCase           =   tf.cast(ids_tensor((self.batch_size, 3)				,							2					)				,							tf.inta					)

        # append to next input_ids and
        _UpperCAmelCase           =   tf.concat([input_ids, next_tokens]				,							axis=-1					)
        _UpperCAmelCase           =   tf.concat([attention_mask, next_attn_mask]				,							axis=-1					)

        _UpperCAmelCase           =   model(_UpperCamelCase				,							attention_mask=_UpperCamelCase					)[0]
        _UpperCAmelCase           =   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
        _UpperCAmelCase           =   int(ids_tensor((1,)				,							output_from_past.shape[-1]					)					)
        _UpperCAmelCase           =   output_from_no_past[:, -3:, random_slice_idx]
        _UpperCAmelCase           =   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 			__UpperCamelCase    (							A__	, A__	, unittest.TestCase    ):
     __A	:  Union[str, Any]							  =   (TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
     __A	:  int							  =   (TFOPTForCausalLM,) if is_tf_available() else ()
     __A	:  Any							  =   (
         {"""feature-extraction""": TFOPTModel, """text-generation""": TFOPTForCausalLM} if is_tf_available() else {}
     )
     __A	:  Dict							  =   False
     __A	:  Union[str, Any]							  =   False
     __A	:  Any							  =   False
     __A	:  Union[str, Any]							  =   10





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   TFOPTModelTester(self					)
        _UpperCAmelCase           =   ConfigTester(self				,							config_class=_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        self.config_tester.run_common_tests()





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.check_decoder_model_past_large_inputs(*_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs_for_common()

        def _get_word_embedding_weight(_UpperCamelCase				,							_UpperCamelCase					):
           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
              _UpperCAmelCase           =   model_class(config=_UpperCamelCase					)
              _UpperCAmelCase           =   _get_word_embedding_weight(_UpperCamelCase				,							model.get_input_embeddings()					)
              _UpperCAmelCase           =   _get_word_embedding_weight(_UpperCamelCase				,							model.get_output_embeddings()					)

              # reshape the embeddings
              model.resize_token_embeddings(_UpperCamelCase					)
              _UpperCAmelCase           =   _get_word_embedding_weight(_UpperCamelCase				,							model.get_input_embeddings()					)
              _UpperCAmelCase           =   _get_word_embedding_weight(_UpperCamelCase				,							model.get_output_embeddings()					)

              # check that the resized embeddings size matches the desired size.
              _UpperCAmelCase           =   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
              _UpperCAmelCase           =   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:
                    _UpperCAmelCase           =   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					)

                 _UpperCAmelCase           =   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:
                       _UpperCAmelCase           =   False
                 self.assertTrue(_UpperCamelCase					)




def      A__       (    SCREAMING_SNAKE_CASE_   :      List[Any]						)  ->  str:






   """simple docstring"""







   return tf.constant(SCREAMING_SNAKE_CASE_				,	dtype=tf.intaa						)




@require_tf
class 			__UpperCamelCase    (							unittest.TestCase    ):
     __A	:  List[Any]							  =   99





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   tf.ones((4, 1)				,							dtype=tf.intaa					) * 2
        _UpperCAmelCase           =   tf.concat([ids_tensor((4, 6)				,							self.vocab_size - 3					) + 3, eos_column_vector]				,							axis=1					)
        _UpperCAmelCase           =   input_ids.shape[0]
        _UpperCAmelCase           =   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 			__UpperCamelCase    (							unittest.TestCase    ):





     @slow
     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   TFOPTModel.from_pretrained('''facebook/opt-350m'''					)
        _UpperCAmelCase           =   _long_tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]					)
        _UpperCAmelCase           =   tf.not_equal(_UpperCamelCase				,							model.config.pad_token_id					)
        with tf.GradientTape():
           _UpperCAmelCase           =   model(input_ids=_UpperCamelCase				,							attention_mask=_UpperCamelCase					).last_hidden_state
        _UpperCAmelCase           =   (1, 11, 512)
        self.assertEqual(output.shape				,							_UpperCamelCase					)
        _UpperCAmelCase           =   tf.constant(
            [[-0.2873, -1.9218, -0.3033], [-1.2710, -0.1338, -0.1902], [0.4095, 0.1214, -1.3121]]					)
        self.assertTrue(np.allclose(output[:, :3, :3]				,							_UpperCamelCase				,							atol=4e-3					)					)

        _UpperCAmelCase           =   tf.function(_UpperCamelCase				,							jit_compile=_UpperCamelCase					)
        _UpperCAmelCase           =   xla_generate(_UpperCamelCase				,							_UpperCamelCase					)[0]
        self.assertTrue(np.allclose(output[:, :3, :3]				,							_UpperCamelCase				,							atol=4e-2					)					)




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





     def 		UpperCamelCase(     self					):
        super().setUp()
        _UpperCAmelCase           =   '''facebook/opt-350m'''





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   TFOPTForCausalLM.from_pretrained(self.path_model					)
        _UpperCAmelCase           =   GPTaTokenizer.from_pretrained(self.path_model					)

        _UpperCAmelCase           =   [
            '''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
        _UpperCAmelCase           =   tokenizer(_UpperCamelCase				,							return_tensors='''tf'''				,							padding=_UpperCamelCase				,							add_special_tokens=_UpperCamelCase					)
        _UpperCAmelCase           =   tf.math.reduce_mean(model(inputs.input_ids				,							attention_mask=inputs.attention_mask					)[0]				,							axis=-1					)
        _UpperCAmelCase           =   tf.constant(
            [
                [1.3851, -13.8923, -10.5229, -10.7533, -0.2309, -10.2384, -0.5365, -9.0947, -5.1670],
                [-4.7073, -10.6276, -3.9415, -21.5242, -0.2822, -0.2822, -0.2822, -0.2822, -0.2822],
                [0.6247, -3.4229, -8.9179, -1.4297, -14.1650, 1.4146, -9.0218, -0.2703, -0.2703],
                [6.4783, -1.9913, -10.7926, -2.3336, 1.5092, -0.9974, -6.8213, 1.3477, 1.3477],
            ]					)
        self.assertTrue(np.allclose(_UpperCamelCase				,							_UpperCamelCase				,							atol=1e-4					)					)

        _UpperCAmelCase           =   tf.function(_UpperCamelCase				,							jit_compile=_UpperCamelCase					)
        _UpperCAmelCase           =   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 			__UpperCamelCase    (							unittest.TestCase    ):





     @property
     def 		UpperCamelCase(     self					):
        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 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   '''facebook/opt-125m'''

        _UpperCAmelCase           =   [
            '''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''',
        ]

        _UpperCAmelCase           =   []
        _UpperCAmelCase           =   GPTaTokenizer.from_pretrained(_UpperCamelCase					)
        _UpperCAmelCase           =   TFOPTForCausalLM.from_pretrained(_UpperCamelCase					)

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

           _UpperCAmelCase           =   model.generate(_UpperCamelCase				,							max_length=10					)

           _UpperCAmelCase           =   tokenizer.batch_decode(_UpperCamelCase				,							skip_special_tokens=_UpperCamelCase					)
           predicted_outputs += generated_string

        self.assertListEqual(_UpperCamelCase				,							_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   '''facebook/opt-350m'''

        _UpperCAmelCase           =   GPTaTokenizer.from_pretrained(_UpperCamelCase					)
        _UpperCAmelCase           =   TFOPTForCausalLM.from_pretrained(_UpperCamelCase					)

        _UpperCAmelCase           =   '''left'''

        # use different length sentences to test batching
        _UpperCAmelCase           =   [
            '''Hello, my dog is a little''',
            '''Today, I''',
        ]

        _UpperCAmelCase           =   tokenizer(_UpperCamelCase				,							return_tensors='''tf'''				,							padding=_UpperCamelCase					)
        _UpperCAmelCase           =   inputs['''input_ids''']

        _UpperCAmelCase           =   model.generate(input_ids=_UpperCamelCase				,							attention_mask=inputs['''attention_mask''']					)

        _UpperCAmelCase           =   tokenizer(sentences[0]				,							return_tensors='''tf'''					).input_ids
        _UpperCAmelCase           =   model.generate(input_ids=_UpperCamelCase					)

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

        _UpperCAmelCase           =   tokenizer.batch_decode(_UpperCamelCase				,							skip_special_tokens=_UpperCamelCase					)
        _UpperCAmelCase           =   tokenizer.decode(output_non_padded[0]				,							skip_special_tokens=_UpperCamelCase					)
        _UpperCAmelCase           =   tokenizer.decode(output_padded[0]				,							skip_special_tokens=_UpperCamelCase					)

        _UpperCAmelCase           =   [
            '''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 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   '''facebook/opt-350m'''

        _UpperCAmelCase           =   [
            '''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''',
        ]

        _UpperCAmelCase           =   []
        _UpperCAmelCase           =   GPTaTokenizer.from_pretrained(_UpperCamelCase					)
        _UpperCAmelCase           =   TFOPTForCausalLM.from_pretrained(_UpperCamelCase					)

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

           _UpperCAmelCase           =   model.generate(_UpperCamelCase				,							max_length=10					)

           _UpperCAmelCase           =   tokenizer.batch_decode(_UpperCamelCase				,							skip_special_tokens=_UpperCamelCase					)
           predicted_outputs += generated_string

        self.assertListEqual(_UpperCamelCase				,							_UpperCamelCase					)






UpperCAmelCase_           =	{
    "A": ".-", "B": "-...", "C": "-.-.", "D": "-..", "E": ".", "F": "..-.", "G": "--.",
    "H": "....", "I": "..", "J": ".---", "K": "-.-", "L": ".-..", "M": "--", "N": "-.",
    "O": "---", "P": ".--.", "Q": "--.-", "R": ".-.", "S": "...", "T": "-", "U": "..-",
    "V": "...-", "W": ".--", "X": "-..-", "Y": "-.--", "Z": "--..", "1": ".----",
    "2": "..---", "3": "...--", "4": "....-", "5": ".....", "6": "-....", "7": "--...",
    "8": "---..", "9": "----.", "0": "-----", "&": ".-...", "@": ".--.-.",
    ":": "---...", ",": "--..--", ".": ".-.-.-", "'": ".----.", "\"": ".-..-.",
    "?": "..--..", "/": "-..-.", "=": "-...-", "+": ".-.-.", "-": "-....-",
    "(": "-.--.", ")": "-.--.-", "!": "-.-.--", " ": "/"
}  # Exclamation mark is not in ITU-R recommendation
# fmt: on
UpperCAmelCase_           =	{value: key for key, value in MORSE_CODE_DICT.items()}
def      A__       (    SCREAMING_SNAKE_CASE_   :      str						)  ->  str:






   """simple docstring"""







   return " ".join(MORSE_CODE_DICT[char] for char in message.upper()						)
def      A__       (    SCREAMING_SNAKE_CASE_   :      str						)  ->  str:






   """simple docstring"""







   return "".join(REVERSE_DICT[char] for char in message.split()						)
def      A__       (    )  ->  None:






   """simple docstring"""







   _UpperCAmelCase           =   '''Morse code here!'''
   print(SCREAMING_SNAKE_CASE_						)
   _UpperCAmelCase           =   encrypt(SCREAMING_SNAKE_CASE_						)
   print(SCREAMING_SNAKE_CASE_						)
   _UpperCAmelCase           =   decrypt(SCREAMING_SNAKE_CASE_						)
   print(SCREAMING_SNAKE_CASE_						)


if __name__ == "__main__":
   main()