


"""simple docstring"""






from __future__ import annotations

import unittest
import warnings

from transformers import AutoTokenizer, MarianConfig, MarianTokenizer, TranslationPipeline, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
from transformers.utils import cached_property

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 TFAutoModelForSeqaSeqLM, TFMarianModel, TFMarianMTModel


@require_tf
class 			SCREAMING_SNAKE_CASE_  :




							'''simple docstring'''





							__magic_name__					:     Any				  =  MarianConfig
							__magic_name__					:     Tuple				  =  {}
							__magic_name__					:     int				  =  '''gelu'''




							def __init__(						self	,					lowerCamelCase__	,					lowerCamelCase__=13	,					lowerCamelCase__=7	,					lowerCamelCase__=True	,					lowerCamelCase__=False	,					lowerCamelCase__=99	,					lowerCamelCase__=32	,					lowerCamelCase__=2	,					lowerCamelCase__=4	,					lowerCamelCase__=37	,					lowerCamelCase__=0.1	,					lowerCamelCase__=0.1	,					lowerCamelCase__=20	,					lowerCamelCase__=2	,					lowerCamelCase__=1	,					lowerCamelCase__=0	,					)   ->	Any:







								'''simple docstring'''




								snake_case__  :						str		=      parent
								snake_case__  :						Tuple		=      batch_size
								snake_case__  :						Tuple		=      seq_length
								snake_case__  :						Dict		=      is_training
								snake_case__  :						Optional[Any]		=      use_labels
								snake_case__  :						List[Any]		=      vocab_size
								snake_case__  :						int		=      hidden_size
								snake_case__  :						List[str]		=      num_hidden_layers
								snake_case__  :						int		=      num_attention_heads
								snake_case__  :						int		=      intermediate_size

								snake_case__  :						Any		=      hidden_dropout_prob
								snake_case__  :						Any		=      attention_probs_dropout_prob
								snake_case__  :						List[Any]		=      max_position_embeddings
								snake_case__  :						List[Any]		=      eos_token_id
								snake_case__  :						Optional[Any]		=      pad_token_id
								snake_case__  :						Optional[Any]		=      bos_token_id




							def        UpperCAmelCase (						self)   ->	int:







								'''simple docstring'''




								snake_case__  :						Union[str, Any]		=      ids_tensor([self.batch_size, self.seq_length - 1]	,					self.vocab_size)
								snake_case__  :						Tuple		=      tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size)	,					1)
								snake_case__  :						Tuple		=      tf.concat([input_ids, eos_tensor]	,					axis=1)

								snake_case__  :						Tuple		=      ids_tensor([self.batch_size, self.seq_length]	,					self.vocab_size)

								snake_case__  :						Union[str, Any]		=      self.config_cls(
								    vocab_size=self.vocab_size	,					d_model=self.hidden_size	,					encoder_layers=self.num_hidden_layers	,					decoder_layers=self.num_hidden_layers	,					encoder_attention_heads=self.num_attention_heads	,					decoder_attention_heads=self.num_attention_heads	,					encoder_ffn_dim=self.intermediate_size	,					decoder_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_ids=[2]	,					bos_token_id=self.bos_token_id	,					pad_token_id=self.pad_token_id	,					decoder_start_token_id=self.pad_token_id	,					**self.config_updates	,					)
								snake_case__  :						Optional[Any]		=      prepare_marian_inputs_dict(lowerCamelCase__	,					lowerCamelCase__	,					lowerCamelCase__)
								return config, inputs_dict







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







								'''simple docstring'''




								snake_case__  :						List[Any]		=      TFMarianModel(config=lowerCamelCase__).get_decoder()
								snake_case__  :						List[Any]		=      inputs_dict["input_ids"]

								snake_case__  :						List[str]		=      input_ids[:1, :]
								snake_case__  :						str		=      inputs_dict["attention_mask"][:1, :]
								snake_case__  :						int		=      inputs_dict["head_mask"]
								snake_case__  :						List[Any]		=      1

								# first forward pass
								snake_case__  :						Tuple		=      model(lowerCamelCase__	,					attention_mask=lowerCamelCase__	,					head_mask=lowerCamelCase__	,					use_cache=lowerCamelCase__)

								snake_case__,					snake_case__  :						int		=      outputs.to_tuple()

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

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

								snake_case__  :						Tuple		=      model(lowerCamelCase__	,					attention_mask=lowerCamelCase__)[0]
								snake_case__  :						Optional[int]		=      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
								snake_case__  :						str		=      int(ids_tensor((1,)	,					output_from_past.shape[-1]))
								snake_case__  :						Tuple		=      output_from_no_past[:, -3:, random_slice_idx]
								snake_case__  :						List[str]		=      output_from_past[:, :, random_slice_idx]

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



def 			A__		(					_UpperCAmelCase    :      Optional[Any]				,    _UpperCAmelCase    :      int				,    _UpperCAmelCase    :      Any				,    _UpperCAmelCase    :      Any=None				,    _UpperCAmelCase    :      str=None				,    _UpperCAmelCase    :      Optional[int]=None				,    _UpperCAmelCase    :      Union[str, Any]=None				,    _UpperCAmelCase    :      Any=None				,    )							->	int:

	'''simple docstring'''


	if attention_mask is None:
		snake_case__  :						Any		=      tf.cast(tf.math.not_equal(_UpperCAmelCase				,    config.pad_token_id	)				,    tf.inta	)
	if decoder_attention_mask is None:
		snake_case__  :						Tuple		=      tf.concat(
		    [
		        tf.ones(decoder_input_ids[:, :1].shape				,    dtype=tf.inta	),
		        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]				,    config.pad_token_id	)				,    tf.inta	),
		    ]				,    axis=-1				,    )
	if head_mask is None:
		snake_case__  :						Any		=      tf.ones((config.encoder_layers, config.encoder_attention_heads)	)
	if decoder_head_mask is None:
		snake_case__  :						str		=      tf.ones((config.decoder_layers, config.decoder_attention_heads)	)
	if cross_attn_head_mask is None:
		snake_case__  :						int		=      tf.ones((config.decoder_layers, config.decoder_attention_heads)	)
	return {
	    "input_ids": input_ids,
	    "decoder_input_ids": decoder_input_ids,
	    "attention_mask": attention_mask,
	    "decoder_attention_mask": decoder_attention_mask,
	    "head_mask": head_mask,
	    "decoder_head_mask": decoder_head_mask,
	    "cross_attn_head_mask": cross_attn_head_mask,
	}


@require_tf
class 			SCREAMING_SNAKE_CASE_  (   _lowercase	,      _lowercase	,      unittest.TestCase):




							'''simple docstring'''





							__magic_name__					:     Tuple				  =  (TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
							__magic_name__					:     int				  =  (TFMarianMTModel,) if is_tf_available() else ()
							__magic_name__					:     Dict				  =  (
							    {
							        '''conversational''': TFMarianMTModel,
							        '''feature-extraction''': TFMarianModel,
							        '''summarization''': TFMarianMTModel,
							        '''text2text-generation''': TFMarianMTModel,
							        '''translation''': TFMarianMTModel,
							    }
							    if is_tf_available()
							    else {}
							)
							__magic_name__					:     Union[str, Any]				  =  True
							__magic_name__					:     List[Any]				  =  False
							__magic_name__					:     str				  =  False




							def        UpperCAmelCase (						self)   ->	Any:







								'''simple docstring'''




								snake_case__  :						Optional[Any]		=      TFMarianModelTester(self)
								snake_case__  :						int		=      ConfigTester(self	,					config_class=lowerCamelCase__)




							def        UpperCAmelCase (						self)   ->	int:







								'''simple docstring'''




								self.config_tester.run_common_tests()







							def        UpperCAmelCase (						self)   ->	Tuple:







								'''simple docstring'''




								snake_case__  :						Any		=      self.model_tester.prepare_config_and_inputs_for_common()
								self.model_tester.check_decoder_model_past_large_inputs(*lowerCamelCase__)


@require_tf
class 			SCREAMING_SNAKE_CASE_  (   unittest.TestCase):




							'''simple docstring'''





							__magic_name__					:     str				  =  10_00  # show more chars for failing integration tests




							@classmethod
							def        UpperCAmelCase (						cls)   ->	None:







								'''simple docstring'''




								snake_case__  :						List[Any]		=      f"""Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}"""
								return cls




							@cached_property
							def        UpperCAmelCase (						self)   ->	MarianTokenizer:







								'''simple docstring'''




								return AutoTokenizer.from_pretrained(self.model_name)




							@property
							def        UpperCAmelCase (						self)   ->	int:







								'''simple docstring'''




								return self.tokenizer.eos_token_id




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







								'''simple docstring'''




								warnings.simplefilter("error")
								snake_case__  :						TFMarianMTModel		=      TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name)
								assert isinstance(lowerCamelCase__	,					lowerCamelCase__)
								snake_case__  :						str		=      model.config
								self.assertListEqual(c.bad_words_ids	,					[[c.pad_token_id]])
								self.assertEqual(c.max_length	,					512)
								self.assertEqual(c.decoder_start_token_id	,					c.pad_token_id)
								return model




							def        UpperCAmelCase (						self	,					**lowerCamelCase__)   ->	Tuple:







								'''simple docstring'''




								snake_case__  :						Tuple		=      self.translate_src_text(**lowerCamelCase__)
								self.assertListEqual(self.expected_text	,					lowerCamelCase__)







							def        UpperCAmelCase (						self	,					**lowerCamelCase__)   ->	Any:







								'''simple docstring'''




								snake_case__  :						Any		=      self.tokenizer(self.src_text	,					**lowerCamelCase__	,					padding=lowerCamelCase__	,					return_tensors="tf")
								snake_case__  :						Any		=      self.model.generate(
								    model_inputs.input_ids	,					attention_mask=model_inputs.attention_mask	,					num_beams=2	,					max_length=128)
								snake_case__  :						Dict		=      self.tokenizer.batch_decode(generated_ids.numpy()	,					skip_special_tokens=lowerCamelCase__)
								return generated_words


@require_sentencepiece
@require_tokenizers
@require_tf
class 			SCREAMING_SNAKE_CASE_  (   _lowercase):




							'''simple docstring'''





							__magic_name__					:     List[str]				  =  '''mt'''
							__magic_name__					:     int				  =  '''en'''
							__magic_name__					:     Any				  =  ['''Billi messu b\'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem.''']
							__magic_name__					:     List[str]				  =  ['''Touching gently, Jesus healed a man who was affected by the sad disease of leprosy.''']




							@unittest.skip("Skipping until #12647 is resolved.")
							@slow
							def        UpperCAmelCase (						self)   ->	Tuple:







								'''simple docstring'''




								self._assert_generated_batch_equal_expected()


@require_sentencepiece
@require_tokenizers
@require_tf
class 			SCREAMING_SNAKE_CASE_  (   _lowercase):




							'''simple docstring'''





							__magic_name__					:     List[str]				  =  '''en'''
							__magic_name__					:     List[Any]				  =  '''zh'''
							__magic_name__					:     int				  =  ['''My name is Wolfgang and I live in Berlin''']
							__magic_name__					:     Tuple				  =  ['''我叫沃尔夫冈 我住在柏林''']




							@unittest.skip("Skipping until #12647 is resolved.")
							@slow
							def        UpperCAmelCase (						self)   ->	Tuple:







								'''simple docstring'''




								self._assert_generated_batch_equal_expected()


@require_sentencepiece
@require_tokenizers
@require_tf
class 			SCREAMING_SNAKE_CASE_  (   _lowercase):




							'''simple docstring'''





							__magic_name__					:     List[str]				  =  '''en'''
							__magic_name__					:     Union[str, Any]				  =  '''ROMANCE'''
							__magic_name__					:     Any				  =  [
							    '''>>fr<< Don\'t spend so much time watching TV.''',
							    '''>>pt<< Your message has been sent.''',
							    '''>>es<< He\'s two years older than me.''',
							]
							__magic_name__					:     Optional[int]				  =  [
							    '''Ne passez pas autant de temps à regarder la télé.''',
							    '''A sua mensagem foi enviada.''',
							    '''Es dos años más viejo que yo.''',
							]




							@unittest.skip("Skipping until #12647 is resolved.")
							@slow
							def        UpperCAmelCase (						self)   ->	int:







								'''simple docstring'''




								self._assert_generated_batch_equal_expected()







							@unittest.skip("Skipping until #12647 is resolved.")
							@slow
							def        UpperCAmelCase (						self)   ->	Any:







								'''simple docstring'''




								snake_case__  :						Optional[Any]		=      TranslationPipeline(self.model	,					self.tokenizer	,					framework="tf")
								snake_case__  :						Union[str, Any]		=      pipeline(self.src_text)
								self.assertEqual(self.expected_text	,					[x["translation_text"] for x in output])









"""simple docstring"""






# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool


lowercase  		=			"""Here is a text containing a lot of information: '''{text}'''.

Can you answer this question about the text: '{question}'"""


class 			SCREAMING_SNAKE_CASE_  (   _lowercase):




							'''simple docstring'''





							__magic_name__					:     List[Any]				  =  '''google/flan-t5-base'''
							__magic_name__					:     Dict				  =  (
							    '''This is a tool that answers questions related to a text. It takes two arguments named `text`, which is the '''
							    '''text where to find the answer, and `question`, which is the question, and returns the answer to the question.'''
							)
							__magic_name__					:     Union[str, Any]				  =  '''text_qa'''
							__magic_name__					:     Union[str, Any]				  =  AutoTokenizer
							__magic_name__					:     List[Any]				  =  AutoModelForSeqaSeqLM

							__magic_name__					:     Tuple				  =  ['''text''', '''text''']
							__magic_name__					:     Tuple				  =  ['''text''']




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







								'''simple docstring'''




								snake_case__  :						str		=      QA_PROMPT.format(text=lowerCamelCase__	,					question=lowerCamelCase__)
								return self.pre_processor(lowerCamelCase__	,					return_tensors="pt")




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







								'''simple docstring'''




								snake_case__  :						Tuple		=      self.model.generate(**lowerCamelCase__)

								snake_case__,					snake_case__  :						Dict		=      inputs["input_ids"].shape
								snake_case__  :						List[Any]		=      output_ids.shape[0]

								return output_ids.reshape(lowerCamelCase__	,					out_b // in_b	,					*output_ids.shape[1:])[0][0]







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







								'''simple docstring'''




								return self.pre_processor.decode(lowerCamelCase__	,					skip_special_tokens=lowerCamelCase__	,					clean_up_tokenization_spaces=lowerCamelCase__)





