





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  SCREAMING_SNAKE_CASE				(      snake_case						,   snake_case						,   snake_case=None						,   snake_case=None							)		->    Any:





		if attention_mask is None:
				__lowercase											=     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 		snake_case_   :







	'''simple docstring'''
	__UpperCamelCase   =		OPTConfig
	__UpperCamelCase   =		{}
	__UpperCamelCase   =		'''gelu'''




	def __init__(						self							:     Dict					,      __lowerCamelCase							:     Union[str, Any]					,      __lowerCamelCase							:     Any=13					,      __lowerCamelCase							:     Tuple=7					,      __lowerCamelCase							:     Optional[int]=True					,      __lowerCamelCase							:     str=False					,      __lowerCamelCase							:     Dict=99					,      __lowerCamelCase							:     Tuple=16					,      __lowerCamelCase							:     Optional[Any]=2					,      __lowerCamelCase							:     Any=4					,      __lowerCamelCase							:     List[str]=4					,      __lowerCamelCase							:     Optional[Any]="gelu"					,      __lowerCamelCase							:     str=0.1					,      __lowerCamelCase							:     Optional[Any]=0.1					,      __lowerCamelCase							:     Dict=20					,      __lowerCamelCase							:     Optional[int]=2					,      __lowerCamelCase							:     Optional[int]=1					,      __lowerCamelCase							:     Union[str, Any]=0					,      __lowerCamelCase							:     Optional[int]=16					,      __lowerCamelCase							:     List[Any]=16					,      )       -> Dict:

			'''simple docstring'''




			__lowercase											=     parent
			__lowercase											=     batch_size
			__lowercase											=     seq_length
			__lowercase											=     is_training
			__lowercase											=     use_labels
			__lowercase											=     vocab_size
			__lowercase											=     hidden_size
			__lowercase											=     num_hidden_layers
			__lowercase											=     num_attention_heads
			__lowercase											=     intermediate_size
			__lowercase											=     hidden_act
			__lowercase											=     hidden_dropout_prob
			__lowercase											=     attention_probs_dropout_prob
			__lowercase											=     max_position_embeddings
			__lowercase											=     eos_token_id
			__lowercase											=     pad_token_id
			__lowercase											=     bos_token_id
			__lowercase											=     embed_dim
			__lowercase											=     word_embed_proj_dim
			__lowercase											=     False




	def    UpperCAmelCase			(						self							:     Any   )       -> str:

			'''simple docstring'''




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

			__lowercase											=     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=__lowerCamelCase					,      **self.config_updates					,      )
			__lowercase											=     prepare_opt_inputs_dict(__lowerCamelCase					,      __lowerCamelCase   )
			return config, inputs_dict






	def    UpperCAmelCase			(						self							:     Optional[Any]					,      __lowerCamelCase							:     Optional[Any]					,      __lowerCamelCase							:     Optional[int]   )       -> Optional[int]:

			'''simple docstring'''




			__lowercase											=     TFOPTModel(config=__lowerCamelCase   )
			__lowercase											=     inputs_dict["input_ids"]

			__lowercase											=     input_ids[:1, :]
			__lowercase											=     inputs_dict["attention_mask"][:1, :]
			__lowercase											=     1

			# first forward pass
			__lowercase											=     model(__lowerCamelCase					,      attention_mask=__lowerCamelCase					,      use_cache=__lowerCamelCase   )

			__lowercase											=     outputs.to_tuple()

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

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

			__lowercase											=     model(__lowerCamelCase					,      attention_mask=__lowerCamelCase   )[0]
			__lowercase											=     model(__lowerCamelCase					,      attention_mask=__lowerCamelCase					,      past_key_values=__lowerCamelCase   )[0]

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

			# select random slice
			__lowercase											=     int(ids_tensor((1,)					,      output_from_past.shape[-1]   )   )
			__lowercase											=     output_from_no_past[:, -3:, random_slice_idx]
			__lowercase											=     output_from_past[:, :, random_slice_idx]

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





@require_tf
class 		snake_case_   (							__lowercase     ,     __lowercase     ,     unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		(TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
	__UpperCamelCase   =		(TFOPTForCausalLM,) if is_tf_available() else ()
	__UpperCamelCase   =		(
	    {'''feature-extraction''': TFOPTModel, '''text-generation''': TFOPTForCausalLM} if is_tf_available() else {}
	)
	__UpperCamelCase   =		False
	__UpperCamelCase   =		False
	__UpperCamelCase   =		False
	__UpperCamelCase   =		10




	def    UpperCAmelCase			(						self							:     Any   )       -> List[Any]:

			'''simple docstring'''




			__lowercase											=     TFOPTModelTester(self   )
			__lowercase											=     ConfigTester(self					,      config_class=__lowerCamelCase   )




	def    UpperCAmelCase			(						self							:     List[str]   )       -> Union[str, Any]:

			'''simple docstring'''




			self.config_tester.run_common_tests()




	def    UpperCAmelCase			(						self							:     List[Any]   )       -> Any:

			'''simple docstring'''




			__lowercase											=     self.model_tester.prepare_config_and_inputs_for_common()
			self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase   )






	def    UpperCAmelCase			(						self							:     Tuple   )       -> int:

			'''simple docstring'''




			__lowercase											=     self.model_tester.prepare_config_and_inputs_for_common()

			def _get_word_embedding_weight(__lowerCamelCase							:     Optional[int]					,      __lowerCamelCase							:     Optional[Any]   ):
					if hasattr(__lowerCamelCase					,      '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(__lowerCamelCase					,      '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
							__lowercase											=     model_class(config=__lowerCamelCase   )
							__lowercase											=     _get_word_embedding_weight(__lowerCamelCase					,      model.get_input_embeddings()   )
							__lowercase											=     _get_word_embedding_weight(__lowerCamelCase					,      model.get_output_embeddings()   )

							# reshape the embeddings
							model.resize_token_embeddings(__lowerCamelCase   )
							__lowercase											=     _get_word_embedding_weight(__lowerCamelCase					,      model.get_input_embeddings()   )
							__lowercase											=     _get_word_embedding_weight(__lowerCamelCase					,      model.get_output_embeddings()   )

							# check that the resized embeddings size matches the desired size.
							__lowercase											=     size if size is not None else config.vocab_size

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

							# check that weights remain the same after resizing
							__lowercase											=     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:
											__lowercase											=     False
							self.assertTrue(__lowerCamelCase   )

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

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





def  SCREAMING_SNAKE_CASE				(      snake_case							)		->    Optional[Any]:
		return tf.constant(_lowerCamelCase						,   dtype=tf.intaa							)

@require_tf
class 		snake_case_   (							unittest.TestCase						):







	'''simple docstring'''
	__UpperCamelCase   =		99




	def    UpperCAmelCase			(						self							:     str   )       -> Union[str, Any]:

			'''simple docstring'''




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







	'''simple docstring'''




	@slow
	def    UpperCAmelCase			(						self							:     Tuple   )       -> Dict:

			'''simple docstring'''




			__lowercase											=     TFOPTModel.from_pretrained('facebook/opt-350m'   )
			__lowercase											=     _long_tensor([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]]   )
			__lowercase											=     tf.not_equal(__lowerCamelCase					,      model.config.pad_token_id   )
			with tf.GradientTape():
					__lowercase											=     model(input_ids=__lowerCamelCase					,      attention_mask=__lowerCamelCase   ).last_hidden_state
			__lowercase											=     (1, 11, 512)
			self.assertEqual(output.shape					,      __lowerCamelCase   )
			__lowercase											=     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]					,      __lowerCamelCase					,      atol=4E-3   )   )

			__lowercase											=     tf.function(__lowerCamelCase					,      jit_compile=__lowerCamelCase   )
			__lowercase											=     xla_generate(__lowerCamelCase					,      __lowerCamelCase   )[0]
			self.assertTrue(np.allclose(output[:, :3, :3]					,      __lowerCamelCase					,      atol=4E-2   )   )





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







	'''simple docstring'''




	def    UpperCAmelCase			(						self							:     List[Any]   )       -> Optional[Any]:

			'''simple docstring'''




			super().setUp()
			__lowercase											=     "facebook/opt-350m"






	def    UpperCAmelCase			(						self							:     Any   )       -> Optional[int]:

			'''simple docstring'''




			__lowercase											=     TFOPTForCausalLM.from_pretrained(self.path_model   )
			__lowercase											=     GPTaTokenizer.from_pretrained(self.path_model   )

			__lowercase											=     [
			    "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
			__lowercase											=     tokenizer(__lowerCamelCase					,      return_tensors='tf'					,      padding=__lowerCamelCase					,      add_special_tokens=__lowerCamelCase   )
			__lowercase											=     tf.math.reduce_mean(model(inputs.input_ids					,      attention_mask=inputs.attention_mask   )[0]					,      axis=-1   )
			__lowercase											=     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(__lowerCamelCase					,      __lowerCamelCase					,      atol=1E-4   )   )

			__lowercase											=     tf.function(__lowerCamelCase					,      jit_compile=__lowerCamelCase   )
			__lowercase											=     tf.math.reduce_mean(xla_generate(inputs.input_ids					,      attention_mask=inputs.attention_mask   )[0]					,      axis=-1   )
			self.assertTrue(np.allclose(__lowerCamelCase					,      __lowerCamelCase					,      atol=1E-4   )   )





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







	'''simple docstring'''




	@property
	def    UpperCAmelCase			(						self							:     Optional[int]   )       -> Optional[Any]:

			'''simple docstring'''




			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							:     Any   )       -> List[str]:

			'''simple docstring'''




			__lowercase											=     "facebook/opt-125m"

			__lowercase											=     [
			    "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",
			]

			__lowercase											=     []
			__lowercase											=     GPTaTokenizer.from_pretrained(__lowerCamelCase   )
			__lowercase											=     TFOPTForCausalLM.from_pretrained(__lowerCamelCase   )

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

					__lowercase											=     model.generate(__lowerCamelCase					,      max_length=10   )

					__lowercase											=     tokenizer.batch_decode(__lowerCamelCase					,      skip_special_tokens=__lowerCamelCase   )
					predicted_outputs += generated_string

			self.assertListEqual(__lowerCamelCase					,      __lowerCamelCase   )




	def    UpperCAmelCase			(						self							:     Optional[int]   )       -> Dict:

			'''simple docstring'''




			__lowercase											=     "facebook/opt-350m"

			__lowercase											=     GPTaTokenizer.from_pretrained(__lowerCamelCase   )
			__lowercase											=     TFOPTForCausalLM.from_pretrained(__lowerCamelCase   )

			__lowercase											=     "left"

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

			__lowercase											=     tokenizer(__lowerCamelCase					,      return_tensors='tf'					,      padding=__lowerCamelCase   )
			__lowercase											=     inputs["input_ids"]

			__lowercase											=     model.generate(input_ids=__lowerCamelCase					,      attention_mask=inputs['attention_mask']   )

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

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

			__lowercase											=     tokenizer.batch_decode(__lowerCamelCase					,      skip_special_tokens=__lowerCamelCase   )
			__lowercase											=     tokenizer.decode(output_non_padded[0]					,      skip_special_tokens=__lowerCamelCase   )
			__lowercase											=     tokenizer.decode(output_padded[0]					,      skip_special_tokens=__lowerCamelCase   )

			__lowercase											=     [
			    "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(__lowerCamelCase					,      __lowerCamelCase   )
			self.assertListEqual(__lowerCamelCase					,      [non_padded_sentence, padded_sentence]   )






	def    UpperCAmelCase			(						self							:     str   )       -> Dict:

			'''simple docstring'''




			__lowercase											=     "facebook/opt-350m"

			__lowercase											=     [
			    "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",
			]

			__lowercase											=     []
			__lowercase											=     GPTaTokenizer.from_pretrained(__lowerCamelCase   )
			__lowercase											=     TFOPTForCausalLM.from_pretrained(__lowerCamelCase   )

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

					__lowercase											=     model.generate(__lowerCamelCase					,      max_length=10   )

					__lowercase											=     tokenizer.batch_decode(__lowerCamelCase					,      skip_special_tokens=__lowerCamelCase   )
					predicted_outputs += generated_string

			self.assertListEqual(__lowerCamelCase					,      __lowerCamelCase   )






import math




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int)   ->       str:






							'''simple docstring'''





							__UpperCamelCase      :  Union[str, Any]       =   0
							__UpperCamelCase      :  int       =   0
							while num > 0:
														__UpperCamelCase      :  List[Any]       =   num % 8
														__UpperCamelCase      :  Tuple       =   octal + (remainder * math.floor(math.pow(10		,    _lowerCamelCase)))
														counter += 1
														__UpperCamelCase      :  Optional[Any]       =   math.floor(num / 8)  # basically /= 8 without remainder if any
														# This formatting removes trailing '.0' from `octal`.
							return F'0o{int(_lowerCamelCase)}'




def       _SCREAMING_SNAKE_CASE   (						)   ->       None:






							'''simple docstring'''





							print("\n2 in octal is:")
							print(decimal_to_octal(2))  # = 2
							print("\n8 in octal is:")
							print(decimal_to_octal(8))  # = 10
							print("\n65 in octal is:")
							print(decimal_to_octal(65))  # = 101
							print("\n216 in octal is:")
							print(decimal_to_octal(216))  # = 330
							print("\n512 in octal is:")
							print(decimal_to_octal(512))  # = 1000
							print("\n")


if __name__ == "__main__":
		main()