





'''simple docstring'''


# Copyright (c) 2021-, NVIDIA CORPORATION.  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.

####################################################################################################

#
# Note: If when running this conversion script you're getting an exception:
#     ModuleNotFoundError: No module named 'megatron.model.enums'
# you need to tell python where to find the clone of Megatron-LM, e.g.:
#
# cd /tmp
# git clone https://github.com/NVIDIA/Megatron-LM
# PYTHONPATH=/tmp/Megatron-LM python src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py ...
#
# if you already have it cloned elsewhere, simply adjust the path to the existing path
#
# If the training was done using a Megatron-LM fork, e.g.,
# https://github.com/microsoft/Megatron-DeepSpeed/ then chances are that you need to have that one
# in your path, i.e., /path/to/Megatron-DeepSpeed/
#

import argparse
import os
import re
import zipfile

import torch

from transformers import MegatronBertConfig




def  __a			(  UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase=0     )   ->Union[str, Any]:



	"""simple docstring"""







	if name is None:
		A					=   None
	else:
		A					=   """.""" * max(0							,      spaces - 2     ) + """# {:""" + str(50 - spaces     ) + """s}"""
		A					=   fmt.format(UpperCAmelCase     )

	# Print and recurse (if needed).
	if isinstance(UpperCAmelCase							,      UpperCAmelCase     ):
		if msg is not None:
			print(UpperCAmelCase     )
		for k in val.keys():
			recursive_print(UpperCAmelCase							,      val[k]							,      spaces + 2     )
	elif isinstance(UpperCAmelCase							,      torch.Tensor     ):
		print(UpperCAmelCase							,      """:"""							,      val.size()     )
	else:
		print(UpperCAmelCase							,      """:"""							,      UpperCAmelCase     )




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



	"""simple docstring"""







	A					=   param.size()
	if checkpoint_version == 1.0:
		# version 1.0 stores [num_heads * hidden_size * num_splits, :]
		A					=   (num_heads, hidden_size, num_splits) + input_shape[1:]
		A					=   param.view(*UpperCAmelCase     )
		A					=   param.transpose(0							,      2     )
		A					=   param.transpose(1							,      2     ).contiguous()
	elif checkpoint_version >= 2.0:
		# other versions store [num_heads * num_splits * hidden_size, :]
		A					=   (num_heads, num_splits, hidden_size) + input_shape[1:]
		A					=   param.view(*UpperCAmelCase     )
		A					=   param.transpose(0							,      1     ).contiguous()
	A					=   param.view(*UpperCAmelCase     )
	return param




def  __a			(  UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase     )   ->Any:



	"""simple docstring"""







	A					=   {}

	# old versions did not store training args
	A					=   input_state_dict.get("""args"""							,      UpperCAmelCase     )
	if ds_args is not None:
		# do not make the user write a config file when the exact dimensions/sizes are already in the checkpoint
		# from pprint import pprint
		# pprint(vars(ds_args))

		A					=   ds_args.tokenizer_type
		A					=   ds_args.padded_vocab_size
		A					=   ds_args.max_position_embeddings
		A					=   ds_args.hidden_size
		A					=   ds_args.num_layers
		A					=   ds_args.num_attention_heads
		A					=   ds_args.ffn_hidden_size if """ffn_hidden_size""" in ds_args else 4 * ds_args.hidden_size
		# pprint(config)

	# The number of heads.
	A					=   config.num_attention_heads
	# The hidden_size per head.
	A					=   config.hidden_size // heads
	# Megatron-LM checkpoint version
	if "checkpoint_version" in input_state_dict.keys():
		A					=   input_state_dict["""checkpoint_version"""]
	else:
		A					=   0.0

	# The model.
	A					=   input_state_dict["""model"""]
	# The language model.
	A					=   model["""language_model"""]
	# The embeddings.
	A					=   lm["""embedding"""]

	# The word embeddings.
	A					=   embeddings["""word_embeddings"""]["""weight"""]
	# Truncate the embedding table to vocab_size rows.
	A					=   word_embeddings[: config.vocab_size, :]
	# Store the word embeddings.
	A					=   word_embeddings

	# The position embeddings.
	A					=   embeddings["""position_embeddings"""]["""weight"""]
	assert pos_embeddings.size(0     ) == config.max_position_embeddings and pos_embeddings.size(1     ) == config.hidden_size
	# Store the position embeddings.
	A					=   pos_embeddings

	# The token-type embeddings.
	A					=   embeddings["""tokentype_embeddings"""]["""weight"""]
	# Store the position embeddings.
	A					=   tokentype_embeddings

	# The transformer.
	A					=   lm["""transformer"""] if """transformer""" in lm.keys() else lm["""encoder"""]

	# The regex to extract layer names.
	A					=   re.compile(R"""layers\.(\d+)\.([a-z0-9_.]+)\.([a-z]+)"""     )

	# The simple map of names for "automated" rules.
	A					=   {
	    """attention.dense""": """.attention.output.dense.""",
	    """self_attention.dense""": """.attention.output.dense.""",
	    """mlp.dense_h_to_4h""": """.intermediate.dense.""",
	    """mlp.dense_4h_to_h""": """.output.dense.""",
	}

	# Keep track of the attention/query/value tensor.
	A					=   None

	# Extract the layers.
	for key, val in transformer.items():
		# Match the name.
		A					=   layer_re.match(UpperCAmelCase     )

		# Stop if that's not a layer
		if m is None:
			break

		# The index of the layer.
		A					=   int(m.group(1     )     )
		# The name of the operation.
		A					=   m.group(2     )
		# Is it a weight or a bias?
		A					=   m.group(3     )

		# The name of the layer.
		A					=   f"""bert.encoder.layer.{layer_idx}"""

		# For layernorm(s), simply store the layer norm.
		if op_name.endswith("""layernorm"""     ):
			A					=   """attention.ln""" if op_name.startswith("""input"""     ) else """ln"""
			A					=   val

		# Transpose the QKV matrix.
		elif (
		    op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
		) and weight_or_bias == "weight":
			# Make sure the QKV pointer is nil.
			assert attention_qkv_weight is None, ""

			A					=   fix_query_key_value_ordering(UpperCAmelCase							,      UpperCAmelCase							,      3							,      UpperCAmelCase							,      UpperCAmelCase     )
			# Store the tensor as we need the bias as well to interleave QKV and biases.
			A					=   out_val

		# Transpose the bias.
		elif (
		    op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
		) and weight_or_bias == "bias":
			# Make sure we read the weight tensor.
			assert attention_qkv_weight is not None, ""

			# Split the QKV matrix into Q, K and V. Megatron stores Q,K,V interleaved.
			A					=   attention_qkv_weight[0 * config.hidden_size : 1 * config.hidden_size, :]
			A					=   attention_qkv_weight[1 * config.hidden_size : 2 * config.hidden_size, :]
			A					=   attention_qkv_weight[2 * config.hidden_size : 3 * config.hidden_size, :]

			A					=   fix_query_key_value_ordering(UpperCAmelCase							,      UpperCAmelCase							,      3							,      UpperCAmelCase							,      UpperCAmelCase     )
			# Split the bias.
			A					=   out_val[0 * config.hidden_size : 1 * config.hidden_size]
			A					=   out_val[1 * config.hidden_size : 2 * config.hidden_size]
			A					=   out_val[2 * config.hidden_size : 3 * config.hidden_size]

			# Store.
			A					=   q
			A					=   q_bias
			A					=   k
			A					=   k_bias
			A					=   v
			A					=   v_bias

			# Clear the stored tensor.
			A					=   None

		# Copy weights and biases as is.
		elif weight_or_bias in ["weight", "bias"]:
			A					=   megatron_to_transformers[op_name]
			A					=   val

    # The final layernorm.
	A					=   transformer["""final_layernorm.weight"""]
	A					=   transformer["""final_layernorm.bias"""]

	# The pooler.
	A					=   lm["""pooler"""]

	# Store the matrix and the bias.
	A					=   pooler["""dense.weight"""]
	A					=   pooler["""dense.bias"""]

	# The LM head from Megatron (for RACE).
	A					=   model["""lm_head"""]

	# The transform matrix.
	A					=   lm_head["""dense.weight"""]
	A					=   lm_head["""dense.bias"""]

	# The transform LN.
	A					=   lm_head["""layernorm.weight"""]
	A					=   lm_head["""layernorm.bias"""]

	# For the decoder, we replicate the weights.
	A					=   word_embeddings
	A					=   lm_head["""bias"""]

	# The classifier from Megatron (for MLNI).
	A					=   model["""binary_head"""]

	# Store the classifier.
	A					=   binary_head["""weight"""]
	A					=   binary_head["""bias"""]

	# It should be done!
	return output_state_dict




def  __a			(  )   ->Optional[Any]:



	"""simple docstring"""







	A					=   argparse.ArgumentParser()
	parser.add_argument("""--print-checkpoint-structure"""							,      action="""store_true"""     )
	parser.add_argument("""path_to_checkpoint"""							,      type=UpperCAmelCase							,      help="""Path to the ZIP file containing the checkpoint"""     )
	parser.add_argument(
	    """--config_file"""							,      default=""""""							,      type=UpperCAmelCase							,      help="""An optional config json file describing the pre-trained model."""							,      )
	A					=   parser.parse_args()

	# Extract the basename.
	A					=   os.path.dirname(args.path_to_checkpoint     )

	# Load the model.
	# the .zip is very optional, let's keep it for backward compatibility
	print(f"""Extracting PyTorch state dictionary from \"{args.path_to_checkpoint}\""""     )
	if args.path_to_checkpoint.endswith(""".zip"""     ):
		with zipfile.ZipFile(args.path_to_checkpoint							,      """r"""     ) as checkpoint:
			with checkpoint.open("""release/mp_rank_00/model_optim_rng.pt"""     ) as pytorch_dict:
				A					=   torch.load(UpperCAmelCase							,      map_location="""cpu"""     )
	else:
		A					=   torch.load(args.path_to_checkpoint							,      map_location="""cpu"""     )

	if args.config_file == "":
		# Default config of megatron-bert 345m
		A					=   MegatronBertConfig()

		# different megatron-bert-*-345m models have different vocab sizes, so override the default
		# config (which is for megatron-bert-cased-345m) with the actual vocab dimension
		A					=   input_state_dict["""model"""]["""lm_head"""]["""bias"""].numel()
	else:
		A					=   MegatronBertConfig.from_json_file(args.config_file     )

	# Convert.
	print("""Converting"""     )
	A					=   convert_megatron_checkpoint(UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase     )

	# Print the structure of converted state dict.
	if args.print_checkpoint_structure:
		recursive_print(UpperCAmelCase							,      UpperCAmelCase     )

	# Store the config to file.
	print("""Saving config"""     )
	config.save_pretrained(UpperCAmelCase     )

	# Store the state_dict to file.
	A					=   os.path.join(UpperCAmelCase							,      """pytorch_model.bin"""     )
	print(f"""Saving checkpoint to \"{output_checkpoint_file}\""""     )
	torch.save(UpperCAmelCase							,      UpperCAmelCase     )


####################################################################################################

if __name__ == "__main__":
				main()

####################################################################################################








'''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	:







		'''simple docstring'''







		__lowerCAmelCase								=     MarianConfig
		__lowerCAmelCase								=     {}
		__lowerCAmelCase								=     '''gelu'''







		def __init__(self    :   Tuple   ,   _lowerCAmelCase    :   Union[str, Any]   ,   _lowerCAmelCase    :   Dict=13   ,   _lowerCAmelCase    :   Optional[int]=7   ,   _lowerCAmelCase    :   str=True   ,   _lowerCAmelCase    :   Optional[int]=False   ,   _lowerCAmelCase    :   Tuple=99   ,   _lowerCAmelCase    :   str=32   ,   _lowerCAmelCase    :   str=2   ,   _lowerCAmelCase    :   Union[str, Any]=4   ,   _lowerCAmelCase    :   Dict=37   ,   _lowerCAmelCase    :   int=0.1   ,   _lowerCAmelCase    :   List[Any]=0.1   ,   _lowerCAmelCase    :   Tuple=20   ,   _lowerCAmelCase    :   List[str]=2   ,   _lowerCAmelCase    :   Any=1   ,   _lowerCAmelCase    :   int=0   ,   ):
			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    :   int   ):
			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(_lowerCAmelCase   ,   _lowerCAmelCase   ,   _lowerCAmelCase   )
			return config, inputs_dict







		def 							A  (self    :   List[Any]   ,   _lowerCAmelCase    :   int   ,   _lowerCAmelCase    :   Any   ):
			A					=   TFMarianModel(config=_lowerCAmelCase   ).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(_lowerCAmelCase   ,   attention_mask=_lowerCAmelCase   ,   head_mask=_lowerCAmelCase   ,   use_cache=_lowerCAmelCase   )

			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(_lowerCAmelCase   ,   attention_mask=_lowerCAmelCase   )[0]
			A					=   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
			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(_lowerCAmelCase   ,   _lowerCAmelCase   ,   rtol=1e-3   )






def  __a			(  UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase=None							,      UpperCAmelCase=None							,      UpperCAmelCase=None							,      UpperCAmelCase=None							,      UpperCAmelCase=None							,      )   ->List[str]:



	"""simple docstring"""







	if attention_mask is None:
		A					=   tf.cast(tf.math.not_equal(UpperCAmelCase							,      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	(							A__		,       A__		,       unittest.TestCase    ):







		'''simple docstring'''







		__lowerCAmelCase								=     (TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
		__lowerCAmelCase								=     (TFMarianMTModel,) if is_tf_available() else ()
		__lowerCAmelCase								=     (
		    {
		        '''conversational''': TFMarianMTModel,
		        '''feature-extraction''': TFMarianModel,
		        '''summarization''': TFMarianMTModel,
		        '''text2text-generation''': TFMarianMTModel,
		        '''translation''': TFMarianMTModel,
		    }
		    if is_tf_available()
		    else {}
		)
		__lowerCAmelCase								=     True
		__lowerCAmelCase								=     False
		__lowerCAmelCase								=     False







		def 							A  (self    :   Tuple   ):
			A					=   TFMarianModelTester(self   )
			A					=   ConfigTester(self   ,   config_class=_lowerCAmelCase   )







		def 							A  (self    :   List[str]   ):
			self.config_tester.run_common_tests()







		def 							A  (self    :   Any   ):
			A					=   self.model_tester.prepare_config_and_inputs_for_common()
			self.model_tester.check_decoder_model_past_large_inputs(*_lowerCAmelCase   )






@require_tf
class 				__UpperCAmelCase	(							unittest.TestCase    ):







		'''simple docstring'''







		__lowerCAmelCase								=     10_00  # show more chars for failing integration tests







		@classmethod
		def 							A  (cls    :   Union[str, Any]   ):
			A					=   F"""Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}"""
			return cls







		@cached_property
		def 							A  (self    :   str   ):
			return AutoTokenizer.from_pretrained(self.model_name   )







		@property
		def 							A  (self    :   Optional[int]   ):
			return self.tokenizer.eos_token_id







		@cached_property
		def 							A  (self    :   Optional[Any]   ):
			warnings.simplefilter("""error"""   )
			A					=   TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name   )
			assert isinstance(_lowerCAmelCase   ,   _lowerCAmelCase   )
			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    :   Optional[int]   ,   **_lowerCAmelCase    :   Any   ):
			A					=   self.translate_src_text(**_lowerCAmelCase   )
			self.assertListEqual(self.expected_text   ,   _lowerCAmelCase   )







		def 							A  (self    :   Union[str, Any]   ,   **_lowerCAmelCase    :   Union[str, Any]   ):
			A					=   self.tokenizer(self.src_text   ,   **_lowerCAmelCase   ,   padding=_lowerCAmelCase   ,   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=_lowerCAmelCase   )
			return generated_words






@require_sentencepiece
@require_tokenizers
@require_tf
class 				__UpperCAmelCase	(							A__    ):







		'''simple docstring'''







		__lowerCAmelCase								=     '''mt'''
		__lowerCAmelCase								=     '''en'''
		__lowerCAmelCase								=     ['''Billi messu b\'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem.''']
		__lowerCAmelCase								=     ['''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    :   str   ):
			self._assert_generated_batch_equal_expected()






@require_sentencepiece
@require_tokenizers
@require_tf
class 				__UpperCAmelCase	(							A__    ):







		'''simple docstring'''







		__lowerCAmelCase								=     '''en'''
		__lowerCAmelCase								=     '''zh'''
		__lowerCAmelCase								=     ['''My name is Wolfgang and I live in Berlin''']
		__lowerCAmelCase								=     ['''我叫沃尔夫冈 我住在柏林''']







		@unittest.skip("""Skipping until #12647 is resolved."""   )
		@slow
		def 							A  (self    :   Any   ):
			self._assert_generated_batch_equal_expected()






@require_sentencepiece
@require_tokenizers
@require_tf
class 				__UpperCAmelCase	(							A__    ):







		'''simple docstring'''







		__lowerCAmelCase								=     '''en'''
		__lowerCAmelCase								=     '''ROMANCE'''
		__lowerCAmelCase								=     [
		    '''>>fr<< Don\'t spend so much time watching TV.''',
		    '''>>pt<< Your message has been sent.''',
		    '''>>es<< He\'s two years older than me.''',
		]
		__lowerCAmelCase								=     [
		    '''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    :   Union[str, Any]   ):
			self._assert_generated_batch_equal_expected()







		@unittest.skip("""Skipping until #12647 is resolved."""   )
		@slow
		def 							A  (self    :   Union[str, Any]   ):
			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]   )

