



"""simple docstring"""







import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple, Union

import numpy as np
import regex as re

from ...utils import is_tf_available, is_torch_available, logging


if TYPE_CHECKING:
							if is_torch_available():
														import torch
							if is_tf_available():
														import tensorflow as tf

from ...tokenization_utils import AddedToken, PreTrainedTokenizer


A     =      logging.get_logger(__name__)

A     =      {
    'vocab_file': 'vocab.json',
    'merges_file': 'merges.txt',
}

A     =      {
    'vocab_file': {
        'Salesforce/codegen-350M-mono': 'https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/vocab.json',
    },
    'merges_file': {
        'Salesforce/codegen-350M-mono': 'https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/merges.txt',
    },
}

A     =      {
    'Salesforce/codegen-350M-mono': 2_0_4_8,
}

@lru_cache()
def 	lowerCAmelCase__      (  )			->				str:
							A    =       (
							    list(range(ord('!'      )					,   ord('~'      ) + 1      )      ) + list(range(ord('¡'      )					,   ord('¬'      ) + 1      )      ) + list(range(ord('®'      )					,   ord('ÿ'      ) + 1      )      )
							)
							A    =       bs[:]
							A    =       0
							for b in range(2**8      ):
														if b not in bs:
																					bs.append(lowerCamelCase__      )
																					cs.append(2**8 + n      )
																					n += 1
							A    =       [chr(lowerCamelCase__      ) for n in cs]
							return dict(zip(lowerCamelCase__					,   lowerCamelCase__      )      )

def 	lowerCAmelCase__      (  lowerCamelCase__      )			->				Optional[int]:
							A    =       set()
							A    =       word[0]
							for char in word[1:]:
														pairs.add((prev_char, char)      )
														A    =       char
							return pairs






class   UpperCAmelCase__		(   UpperCamelCase  ):
		lowerCAmelCase_							:						Dict							=  VOCAB_FILES_NAMES
		lowerCAmelCase_							:						List[str]							=  PRETRAINED_VOCAB_FILES_MAP
		lowerCAmelCase_							:						List[str]							=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		lowerCAmelCase_							:						Union[str, Any]							=  ["""input_ids""", """attention_mask"""]



		def __init__(			self	:     Tuple   ,				snake_case	:     Optional[Any]   ,				snake_case	:     Union[str, Any]   ,				snake_case	:     List[Any]="replace"   ,				snake_case	:     Any="<|endoftext|>"   ,				snake_case	:     Tuple="<|endoftext|>"   ,				snake_case	:     str="<|endoftext|>"   ,				snake_case	:     List[Any]=None   ,				snake_case	:     List[str]=False   ,				snake_case	:     List[Any]=False   ,				**snake_case	:     List[str]   ,				)      ->    Optional[int]:






									'''simple docstring'''

									A    =       AddedToken(snake_case   ,				lstrip=snake_case   ,				rstrip=snake_case					) if isinstance(snake_case   ,				snake_case					) else bos_token
									A    =       AddedToken(snake_case   ,				lstrip=snake_case   ,				rstrip=snake_case					) if isinstance(snake_case   ,				snake_case					) else eos_token
									A    =       AddedToken(snake_case   ,				lstrip=snake_case   ,				rstrip=snake_case					) if isinstance(snake_case   ,				snake_case					) else unk_token
									A    =       AddedToken(snake_case   ,				lstrip=snake_case   ,				rstrip=snake_case					) if isinstance(snake_case   ,				snake_case					) else pad_token
									super().__init__(
									    errors=snake_case   ,				unk_token=snake_case   ,				bos_token=snake_case   ,				eos_token=snake_case   ,				pad_token=snake_case   ,				add_prefix_space=snake_case   ,				add_bos_token=snake_case   ,				**snake_case   ,				)
									A    =       add_bos_token

									with open(snake_case   ,				encoding='utf-8'					) as vocab_handle:
																A    =       json.load(snake_case					)
									A    =       {v: k for k, v in self.encoder.items()}
									A    =       errors  # how to handle errors in decoding
									A    =       bytes_to_unicode()
									A    =       {v: k for k, v in self.byte_encoder.items()}
									with open(snake_case   ,				encoding='utf-8'					) as merges_handle:
																A    =       merges_handle.read().split('\n'					)[1:-1]
									A    =       [tuple(merge.split()					) for merge in bpe_merges]
									A    =       dict(zip(snake_case   ,				range(len(snake_case					)					)					)					)
									A    =       {}
									A    =       add_prefix_space

									# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
									A    =       re.compile(r'\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+'					)



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






									'''simple docstring'''

									return len(self.encoder					)



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






									'''simple docstring'''

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



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






									'''simple docstring'''

									if token in self.cache:
																return self.cache[token]
									A    =       tuple(snake_case					)
									A    =       get_pairs(snake_case					)

									if not pairs:
																return token

									while True:
																A    =       min(snake_case   ,				key=lambda snake_case					: self.bpe_ranks.get(snake_case   ,				float('inf'					)					)					)
																if bigram not in self.bpe_ranks:
																							break
																A   ,	A    =       bigram
																A    =       []
																A    =       0
																while i < len(snake_case					):
																							try:
																														A    =       word.index(snake_case   ,				snake_case					)
																							except ValueError:
																														new_word.extend(word[i:]					)
																														break
																							else:
																														new_word.extend(word[i:j]					)
																														A    =       j

																							if word[i] == first and i < len(snake_case					) - 1 and word[i + 1] == second:
																														new_word.append(first + second					)
																														i += 2
																							else:
																														new_word.append(word[i]					)
																														i += 1
																A    =       tuple(snake_case					)
																A    =       new_word
																if len(snake_case					) == 1:
																							break
																else:
																							A    =       get_pairs(snake_case					)
									A    =       ' '.join(snake_case					)
									A    =       word
									return word



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






									'''simple docstring'''

									if self.add_bos_token:
																A    =       [self.bos_token_id]
									else:
																A    =       []

									A    =       bos_token_ids + token_ids_a

									if token_ids_a is None:
																return output

									return output + bos_token_ids + token_ids_a



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






									'''simple docstring'''

									A    =       []
									for token in re.findall(self.pat   ,				snake_case					):
																A    =       ''.join(
																    self.byte_encoder[b] for b in token.encode('utf-8'					)					)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
																bpe_tokens.extend(bpe_token for bpe_token in self.bpe(snake_case					).split(' '					)					)
									return bpe_tokens



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






									'''simple docstring'''

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



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






									'''simple docstring'''

									return self.decoder.get(snake_case					)



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






									'''simple docstring'''

									A    =       ''.join(snake_case					)
									A    =       bytearray([self.byte_decoder[c] for c in text]					).decode('utf-8'   ,				errors=self.errors					)
									return text



		def        A_		(			self	:     List[Any]   ,				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    =       os.path.join(
									    snake_case   ,				(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']					)
									A    =       os.path.join(
									    snake_case   ,				(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file']					)

									with open(snake_case   ,				'w'   ,				encoding='utf-8'					) as f:
																f.write(json.dumps(self.encoder   ,				indent=2   ,				sort_keys=snake_case   ,				ensure_ascii=snake_case					) + '\n'					)

									A    =       0
									with open(snake_case   ,				'w'   ,				encoding='utf-8'					) as writer:
																writer.write('#version: 0.2\n'					)
																for bpe_tokens, token_index in sorted(self.bpe_ranks.items()   ,				key=lambda snake_case					: kv[1]					):
																							if index != token_index:
																														logger.warning(
																														    f"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
																														    ' Please check that the tokenizer is not corrupted!'					)
																														A    =       token_index
																							writer.write(' '.join(snake_case					) + '\n'					)
																							index += 1

									return vocab_file, merge_file



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






									'''simple docstring'''

									A    =       kwargs.pop('add_prefix_space'   ,				self.add_prefix_space					)
									if is_split_into_words or add_prefix_space:
																A    =       ' ' + text
									return (text, kwargs)



		def        A_		(			self	:     List[str]   ,				snake_case	:     Union[int, List[int], "np.ndarray", "torch.Tensor", "tf.Tensor"]   ,				snake_case	:     bool = False   ,				snake_case	:     bool = None   ,				snake_case	:     Optional[List[str]] = None   ,				**snake_case	:     Union[str, Any]   ,				)      ->    str:






									'''simple docstring'''

									A    =       super()._decode(
									    token_ids=snake_case   ,				skip_special_tokens=snake_case   ,				clean_up_tokenization_spaces=snake_case   ,				**snake_case   ,				)

									if truncate_before_pattern is not None and len(snake_case					) > 0:
																A    =       self.truncate(snake_case   ,				snake_case					)

									return decoded_text



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






									'''simple docstring'''

									def find_re(snake_case	:     Optional[int]   ,				snake_case	:     Union[str, Any]   ,				snake_case	:     Any					):
																A    =       pattern.search(snake_case   ,				snake_case					)
																return m.start() if m else -1

									A    =       [re.compile(snake_case   ,				re.MULTILINE					) for pattern in truncate_before_pattern]

									A    =       list(re.finditer('^print'   ,				snake_case   ,				re.MULTILINE					)					)

									if len(snake_case					) > 1:
																A    =       completion[: prints[1].start()]

									A    =       list(re.finditer('^def'   ,				snake_case   ,				re.MULTILINE					)					)

									if len(snake_case					) > 1:
																A    =       completion[: defs[1].start()]

									A    =       0

									A    =       [
									    pos for pos in [find_re(snake_case   ,				snake_case   ,				snake_case					) for terminal in terminals] if pos != -1
									]

									if len(snake_case					) > 0:
																return completion[: min(snake_case					)]
									else:
																return completion








"""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]					)



