



"""simple docstring"""







import json
import os
import re
import warnings
from pathlib import Path
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple, Union

import sentencepiece

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


A     =      logging.get_logger(__name__)

A     =      {
    'source_spm': 'source.spm',
    'target_spm': 'target.spm',
    'vocab': 'vocab.json',
    'target_vocab_file': 'target_vocab.json',
    'tokenizer_config_file': 'tokenizer_config.json',
}

A     =      {
    'source_spm': {
        'Helsinki-NLP/opus-mt-en-de': 'https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/source.spm'
    },
    'target_spm': {
        'Helsinki-NLP/opus-mt-en-de': 'https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/target.spm'
    },
    'vocab': {
        'Helsinki-NLP/opus-mt-en-de': 'https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/vocab.json'
    },
    'tokenizer_config_file': {
        'Helsinki-NLP/opus-mt-en-de': (
            'https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/tokenizer_config.json'
        )
    },
}

A     =      {'Helsinki-NLP/opus-mt-en-de': 5_1_2}
A     =      {}






class   UpperCAmelCase__		(   UpperCamelCase  ):
		lowerCAmelCase_							:						Tuple							=  VOCAB_FILES_NAMES
		lowerCAmelCase_							:						Optional[Any]							=  PRETRAINED_VOCAB_FILES_MAP
		lowerCAmelCase_							:						List[Any]							=  PRETRAINED_INIT_CONFIGURATION
		lowerCAmelCase_							:						List[Any]							=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		lowerCAmelCase_							:						List[str]							=  ["""input_ids""", """attention_mask"""]
		lowerCAmelCase_							:						List[Any]							=  re.compile(""">>.+<<"""  )  # type: re.Pattern



		def __init__(			self	:     Optional[Any]   ,				snake_case	:     str   ,				snake_case	:     List[Any]   ,				snake_case	:     Any   ,				snake_case	:     Optional[Any]=None   ,				snake_case	:     str=None   ,				snake_case	:     Optional[Any]=None   ,				snake_case	:     List[str]="<unk>"   ,				snake_case	:     Optional[Any]="</s>"   ,				snake_case	:     int="<pad>"   ,				snake_case	:     List[str]=512   ,				snake_case	:     Optional[Dict[str, Any]] = None   ,				snake_case	:     Optional[int]=False   ,				**snake_case	:     str   ,				)      ->    None:






									'''simple docstring'''

									A    =       {} if sp_model_kwargs is None else sp_model_kwargs

									super().__init__(
									    # bos_token=bos_token,  unused. Start decoding with config.decoder_start_token_id
									    source_lang=snake_case   ,				target_lang=snake_case   ,				unk_token=snake_case   ,				eos_token=snake_case   ,				pad_token=snake_case   ,				model_max_length=snake_case   ,				sp_model_kwargs=self.sp_model_kwargs   ,				target_vocab_file=snake_case   ,				separate_vocabs=snake_case   ,				**snake_case   ,				)
									assert Path(snake_case					).exists(), f"""cannot find spm source {source_spm}"""

									A    =       separate_vocabs
									A    =       load_json(snake_case					)
									if self.unk_token not in self.encoder:
																raise KeyError('<unk> token must be in vocab'					)
									assert self.pad_token in self.encoder

									if separate_vocabs:
																A    =       load_json(snake_case					)
																A    =       {v: k for k, v in self.target_encoder.items()}
																A    =       []
									else:
																A    =       {v: k for k, v in self.encoder.items()}
																A    =       [k for k in self.encoder if k.startswith('>>'					) and k.endswith('<<'					)]

									A    =       source_lang
									A    =       target_lang
									A    =       [source_spm, target_spm]

									# load SentencePiece model for pre-processing
									A    =       load_spm(snake_case   ,				self.sp_model_kwargs					)
									A    =       load_spm(snake_case   ,				self.sp_model_kwargs					)
									A    =       self.spm_source
									A    =       self.encoder

									# Multilingual target side: default to using first supported language code.

									self._setup_normalizer()



		def        A_		(			self	:     str					)      ->    Optional[Any]:






									'''simple docstring'''

									try:
																from sacremoses import MosesPunctNormalizer

																A    =       MosesPunctNormalizer(self.source_lang					).normalize
									except (ImportError, FileNotFoundError):
																warnings.warn('Recommended: pip install sacremoses.'					)
																A    =       lambda snake_case					: x



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






									'''simple docstring'''

									return self.punc_normalizer(snake_case					) if x else ""



		def        A_		(			self	:     List[str]   ,				snake_case	:     List[Any]					)      ->    Optional[int]:






									'''simple docstring'''

									return self.current_encoder.get(snake_case   ,				self.current_encoder[self.unk_token]					)



		def        A_		(			self	:     List[str]   ,				snake_case	:     str					)      ->    str:






									'''simple docstring'''

									A    =       self.language_code_re.match(snake_case					)
									A    =       [match.group(0					)] if match else []
									return code, self.language_code_re.sub(''   ,				snake_case					)



		def        A_		(			self	:     Any   ,				snake_case	:     str					)      ->    List[str]:






									'''simple docstring'''

									A   ,	A    =       self.remove_language_code(snake_case					)
									A    =       self.current_spm.encode(snake_case   ,				out_type=snake_case					)
									return code + pieces



		def        A_		(			self	:     str   ,				snake_case	:     int					)      ->    str:






									'''simple docstring'''

									return self.decoder.get(snake_case   ,				self.unk_token					)



		def        A_		(			self	:     List[str]   ,				snake_case	:     List[str]   ,				**snake_case	:     List[Any]					)      ->    int:






									'''simple docstring'''

									return super().batch_decode(snake_case   ,				**snake_case					)



		def        A_		(			self	:     Optional[Any]   ,				snake_case	:     int   ,				**snake_case	:     Union[str, Any]					)      ->    int:






									'''simple docstring'''

									return super().decode(snake_case   ,				**snake_case					)



		def        A_		(			self	:     Optional[Any]   ,				snake_case	:     List[str]					)      ->    str:






									'''simple docstring'''

									A    =       self.spm_source if self._decode_use_source_tokenizer else self.spm_target
									A    =       []
									A    =       ''
									for token in tokens:
																# make sure that special tokens are not decoded using sentencepiece model
																if token in self.all_special_tokens:
																							out_string += sp_model.decode_pieces(snake_case					) + token + " "
																							A    =       []
																else:
																							current_sub_tokens.append(snake_case					)
									out_string += sp_model.decode_pieces(snake_case					)
									return out_string.strip()



		def        A_		(			self	:     Dict   ,				snake_case	:     Optional[Any]   ,				snake_case	:     List[str]=None					)      ->    List[int]:






									'''simple docstring'''

									if token_ids_a is None:
																return token_ids_a + [self.eos_token_id]
									# We don't expect to process pairs, but leave the pair logic for API consistency
									return token_ids_a + token_ids_a + [self.eos_token_id]



		def        A_		(			self	:     str					)      ->    List[str]:






									'''simple docstring'''

									A    =       self.spm_source
									A    =       self.encoder



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






									'''simple docstring'''

									A    =       self.spm_target
									if self.separate_vocabs:
																A    =       self.target_encoder



		@property
		def        A_		(			self	:     str					)      ->    int:






									'''simple docstring'''

									return len(self.encoder					)



		def        A_		(			self	:     List[str]   ,				snake_case	:     str   ,				snake_case	:     Optional[str] = None					)      ->    Tuple[str]:






									'''simple docstring'''

									if not os.path.isdir(snake_case					):
																logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""					)
																return
									A    =       []

									if self.separate_vocabs:
																A    =       os.path.join(
																    snake_case   ,				(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab']   ,				)
																A    =       os.path.join(
																    snake_case   ,				(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['target_vocab_file']   ,				)
																save_json(self.encoder   ,				snake_case					)
																save_json(self.target_encoder   ,				snake_case					)
																saved_files.append(snake_case					)
																saved_files.append(snake_case					)
									else:
																A    =       os.path.join(
																    snake_case   ,				(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab']					)
																save_json(self.encoder   ,				snake_case					)
																saved_files.append(snake_case					)

									for spm_save_filename, spm_orig_path, spm_model in zip(
									    [VOCAB_FILES_NAMES['source_spm'], VOCAB_FILES_NAMES['target_spm']]   ,				self.spm_files   ,				[self.spm_source, self.spm_target]   ,				):
																A    =       os.path.join(
																    snake_case   ,				(filename_prefix + '-' if filename_prefix else '') + spm_save_filename					)
																if os.path.abspath(snake_case					) != os.path.abspath(snake_case					) and os.path.isfile(snake_case					):
																							copyfile(snake_case   ,				snake_case					)
																							saved_files.append(snake_case					)
																elif not os.path.isfile(snake_case					):
																							with open(snake_case   ,				'wb'					) as fi:
																														A    =       spm_model.serialized_model_proto()
																														fi.write(snake_case					)
																							saved_files.append(snake_case					)

									return tuple(snake_case					)



		def        A_		(			self	:     Tuple					)      ->    Dict:






									'''simple docstring'''

									return self.get_src_vocab()



		def        A_		(			self	:     List[Any]					)      ->    Tuple:






									'''simple docstring'''

									return dict(self.encoder   ,				**self.added_tokens_encoder					)



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






									'''simple docstring'''

									return dict(self.target_encoder   ,				**self.added_tokens_decoder					)



		def __getstate__(			self	:     Any					)      ->    Dict:






									'''simple docstring'''

									A    =       self.__dict__.copy()
									state.update(
									    {k: None for k in ['spm_source', 'spm_target', 'current_spm', 'punc_normalizer', 'target_vocab_file']}					)
									return state



		def __setstate__(			self	:     Optional[int]   ,				snake_case	:     Dict					)      ->    None:






									'''simple docstring'''

									A    =       d

									# for backward compatibility
									if not hasattr(self   ,				'sp_model_kwargs'					):
																A    =       {}

									A   ,	A    =       (load_spm(snake_case   ,				self.sp_model_kwargs					) for f in self.spm_files)
									A    =       self.spm_source
									self._setup_normalizer()



		def        A_		(			self	:     Any   ,				*snake_case	:     Dict   ,				**snake_case	:     str					)      ->    Tuple:






									'''simple docstring'''

									return 1



		def        A_		(			self	:     Optional[Any]   ,				snake_case	:     Any					)      ->    Tuple:






									'''simple docstring'''

									A    =       set(self.all_special_ids					)  # call it once instead of inside list comp
									all_special_ids.remove(self.unk_token_id					)  # <unk> is only sometimes special
									return [1 if x in all_special_ids else 0 for x in seq]



		def        A_		(			self	:     int   ,				snake_case	:     List   ,				snake_case	:     Optional[List] = None   ,				snake_case	:     bool = False					)      ->    List[int]:






									'''simple docstring'''

									if already_has_special_tokens:
																return self._special_token_mask(snake_case					)
									elif token_ids_a is None:
																return self._special_token_mask(snake_case					) + [1]
									else:
																return self._special_token_mask(token_ids_a + token_ids_a					) + [1]



def 	lowerCAmelCase__      (  lowerCamelCase__					,   lowerCamelCase__      )			->				sentencepiece.SentencePieceProcessor:
							A    =       sentencepiece.SentencePieceProcessor(**lowerCamelCase__      )
							spm.Load(lowerCamelCase__      )
							return spm

def 	lowerCAmelCase__      (  lowerCamelCase__					,   lowerCamelCase__      )			->				None:
							with open(lowerCamelCase__					,   'w'      ) as f:
														json.dump(lowerCamelCase__					,   lowerCamelCase__					,   indent=2      )

def 	lowerCAmelCase__      (  lowerCamelCase__      )			->				Union[Dict, List]:
							with open(lowerCamelCase__					,   'r'      ) as f:
														return json.load(lowerCamelCase__      )








"""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   UpperCAmelCase__		:
		lowerCAmelCase_							:						Optional[Any]							=  MarianConfig
		lowerCAmelCase_							:						Dict							=  {}
		lowerCAmelCase_							:						List[str]							=  """gelu"""



		def __init__(			self	:     Optional[Any]   ,				snake_case	:     Any   ,				snake_case	:     int=13   ,				snake_case	:     Dict=7   ,				snake_case	:     Dict=True   ,				snake_case	:     List[str]=False   ,				snake_case	:     int=99   ,				snake_case	:     Optional[Any]=32   ,				snake_case	:     Optional[Any]=2   ,				snake_case	:     int=4   ,				snake_case	:     Optional[int]=37   ,				snake_case	:     Optional[int]=0.1   ,				snake_case	:     str=0.1   ,				snake_case	:     Any=20   ,				snake_case	:     Dict=2   ,				snake_case	:     List[Any]=1   ,				snake_case	:     str=0   ,				)      ->    str:






									'''simple docstring'''

									A    =       parent
									A    =       batch_size
									A    =       seq_length
									A    =       is_training
									A    =       use_labels
									A    =       vocab_size
									A    =       hidden_size
									A    =       num_hidden_layers
									A    =       num_attention_heads
									A    =       intermediate_size

									A    =       hidden_dropout_prob
									A    =       attention_probs_dropout_prob
									A    =       max_position_embeddings
									A    =       eos_token_id
									A    =       pad_token_id
									A    =       bos_token_id



		def        A_		(			self	:     List[Any]					)      ->    Tuple:






									'''simple docstring'''

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

									A    =       ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size					)

									A    =       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   ,				)
									A    =       prepare_marian_inputs_dict(snake_case   ,				snake_case   ,				snake_case					)
									return config, inputs_dict



		def        A_		(			self	:     Tuple   ,				snake_case	:     Optional[int]   ,				snake_case	:     Optional[int]					)      ->    Optional[int]:






									'''simple docstring'''

									A    =       TFMarianModel(config=snake_case					).get_decoder()
									A    =       inputs_dict['input_ids']

									A    =       input_ids[:1, :]
									A    =       inputs_dict['attention_mask'][:1, :]
									A    =       inputs_dict['head_mask']
									A    =       1

									# first forward pass
									A    =       model(snake_case   ,				attention_mask=snake_case   ,				head_mask=snake_case   ,				use_cache=snake_case					)

									A   ,	A    =       outputs.to_tuple()

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

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

									A    =       model(snake_case   ,				attention_mask=snake_case					)[0]
									A    =       model(snake_case   ,				attention_mask=snake_case   ,				past_key_values=snake_case					)[0]

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

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

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



def 	lowerCAmelCase__      (  lowerCamelCase__					,   lowerCamelCase__					,   lowerCamelCase__					,   lowerCamelCase__=None					,   lowerCamelCase__=None					,   lowerCamelCase__=None					,   lowerCamelCase__=None					,   lowerCamelCase__=None					,   )			->				Tuple:
							if attention_mask is None:
														A    =       tf.cast(tf.math.not_equal(lowerCamelCase__					,   config.pad_token_id      )					,   tf.inta      )
							if decoder_attention_mask is None:
														A    =       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:
														A    =       tf.ones((config.encoder_layers, config.encoder_attention_heads)      )
							if decoder_head_mask is None:
														A    =       tf.ones((config.decoder_layers, config.decoder_attention_heads)      )
							if cross_attn_head_mask is None:
														A    =       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   UpperCAmelCase__		(   UpperCamelCase ,UpperCamelCase ,unittest.TestCase  ):
		lowerCAmelCase_							:						List[str]							=  (TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
		lowerCAmelCase_							:						List[Any]							=  (TFMarianMTModel,) if is_tf_available() else ()
		lowerCAmelCase_							:						str							=  (
		    {
		        """conversational""": TFMarianMTModel,
		        """feature-extraction""": TFMarianModel,
		        """summarization""": TFMarianMTModel,
		        """text2text-generation""": TFMarianMTModel,
		        """translation""": TFMarianMTModel,
		    }
		    if is_tf_available()
		    else {}
		)
		lowerCAmelCase_							:						Dict							=  True
		lowerCAmelCase_							:						Any							=  False
		lowerCAmelCase_							:						int							=  False



		def        A_		(			self	:     str					)      ->    Optional[int]:






									'''simple docstring'''

									A    =       TFMarianModelTester(self					)
									A    =       ConfigTester(self   ,				config_class=snake_case					)



		def        A_		(			self	:     int					)      ->    Optional[int]:






									'''simple docstring'''

									self.config_tester.run_common_tests()



		def        A_		(			self	:     Dict					)      ->    int:






									'''simple docstring'''

									A    =       self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.check_decoder_model_past_large_inputs(*snake_case					)






@require_tf
class   UpperCAmelCase__		(   unittest.TestCase  ):
		lowerCAmelCase_							:						str							=  10_00  # show more chars for failing integration tests



		@classmethod
		def        A_		(			cls	:     str					)      ->    None:






									'''simple docstring'''

									A    =       f"""Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}"""
									return cls



		@cached_property
		def        A_		(			self	:     Tuple					)      ->    MarianTokenizer:






									'''simple docstring'''

									return AutoTokenizer.from_pretrained(self.model_name					)



		@property
		def        A_		(			self	:     str					)      ->    int:






									'''simple docstring'''

									return self.tokenizer.eos_token_id



		@cached_property
		def        A_		(			self	:     List[Any]					)      ->    Optional[int]:






									'''simple docstring'''

									warnings.simplefilter('error'					)
									A    =       TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name					)
									assert isinstance(snake_case   ,				snake_case					)
									A    =       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        A_		(			self	:     List[Any]   ,				**snake_case	:     Optional[int]					)      ->    Any:






									'''simple docstring'''

									A    =       self.translate_src_text(**snake_case					)
									self.assertListEqual(self.expected_text   ,				snake_case					)



		def        A_		(			self	:     Optional[Any]   ,				**snake_case	:     int					)      ->    str:






									'''simple docstring'''

									A    =       self.tokenizer(self.src_text   ,				**snake_case   ,				padding=snake_case   ,				return_tensors='tf'					)
									A    =       self.model.generate(
									    model_inputs.input_ids   ,				attention_mask=model_inputs.attention_mask   ,				num_beams=2   ,				max_length=128					)
									A    =       self.tokenizer.batch_decode(generated_ids.numpy()   ,				skip_special_tokens=snake_case					)
									return generated_words






@require_sentencepiece
@require_tokenizers
@require_tf
class   UpperCAmelCase__		(   UpperCamelCase  ):
		lowerCAmelCase_							:						Dict							=  """mt"""
		lowerCAmelCase_							:						int							=  """en"""
		lowerCAmelCase_							:						Optional[int]							=  ["""Billi messu b'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem."""]
		lowerCAmelCase_							:						List[Any]							=  ["""Touching gently, Jesus healed a man who was affected by the sad disease of leprosy."""]



		@unittest.skip('Skipping until #12647 is resolved.'					)
		@slow
		def        A_		(			self	:     List[str]					)      ->    List[Any]:






									'''simple docstring'''

									self._assert_generated_batch_equal_expected()






@require_sentencepiece
@require_tokenizers
@require_tf
class   UpperCAmelCase__		(   UpperCamelCase  ):
		lowerCAmelCase_							:						List[str]							=  """en"""
		lowerCAmelCase_							:						Dict							=  """zh"""
		lowerCAmelCase_							:						Any							=  ["""My name is Wolfgang and I live in Berlin"""]
		lowerCAmelCase_							:						int							=  ["""我叫沃尔夫冈 我住在柏林"""]



		@unittest.skip('Skipping until #12647 is resolved.'					)
		@slow
		def        A_		(			self	:     Tuple					)      ->    List[str]:






									'''simple docstring'''

									self._assert_generated_batch_equal_expected()






@require_sentencepiece
@require_tokenizers
@require_tf
class   UpperCAmelCase__		(   UpperCamelCase  ):
		lowerCAmelCase_							:						str							=  """en"""
		lowerCAmelCase_							:						Dict							=  """ROMANCE"""
		lowerCAmelCase_							:						Optional[int]							=  [
		    """>>fr<< Don't spend so much time watching TV.""",
		    """>>pt<< Your message has been sent.""",
		    """>>es<< He's two years older than me.""",
		]
		lowerCAmelCase_							:						Union[str, Any]							=  [
		    """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        A_		(			self	:     Optional[int]					)      ->    List[Any]:






									'''simple docstring'''

									self._assert_generated_batch_equal_expected()



		@unittest.skip('Skipping until #12647 is resolved.'					)
		@slow
		def        A_		(			self	:     Tuple					)      ->    List[str]:






									'''simple docstring'''

									A    =       TranslationPipeline(self.model   ,				self.tokenizer   ,				framework='tf'					)
									A    =       pipeline(self.src_text					)
									self.assertEqual(self.expected_text   ,				[x['translation_text'] for x in output]					)



