






"""simple docstring"""







import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
			import tensorflow as tf

			tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
			import torch

if is_datasets_available():
			from datasets import load_dataset


a :				int      					=		5e-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors





def 						lowercase__(A						)				->List[str]:




						"""simple docstring"""



						return PTtoTFCommand(
						    args.model_name					,		args.local_dir					,		args.max_error					,		args.new_weights					,		args.no_pr					,		args.push					,		args.extra_commit_description					,		args.override_model_class					,		)







class     __UpperCAmelCase(   __snake_case							):




						"""simple docstring"""




						@staticmethod
						def 		UpperCAmelCase_       (   snake_case__			):
												'''simple docstring'''
												lowercase__				:      List[str]=       parser.add_parser(
												    "pt-to-tf"       ,  help=(
												        "CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint."
												        " Can also be used to validate existing weights without opening PRs, with --no-pr."
												    )       ,  )
												train_parser.add_argument(
												    "--model-name"       ,  type=snake_case__       ,  required=snake_case__       ,  help="The model name, including owner/organization, as seen on the hub."       ,  )
												train_parser.add_argument(
												    "--local-dir"       ,  type=snake_case__       ,  default=""       ,  help="Optional local directory of the model repository. Defaults to /tmp/{model_name}"       ,  )
												train_parser.add_argument(
												    "--max-error"       ,  type=snake_case__       ,  default=snake_case__       ,  help=(
												        F'''Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk.'''
												    )       ,  )
												train_parser.add_argument(
												    "--new-weights"       ,  action="store_true"       ,  help="Optional flag to create new TensorFlow weights, even if they already exist."       ,  )
												train_parser.add_argument(
												    "--no-pr"       ,  action="store_true"       ,  help="Optional flag to NOT open a PR with converted weights."			)
												train_parser.add_argument(
												    "--push"       ,  action="store_true"       ,  help="Optional flag to push the weights directly to `main` (requires permissions)"       ,  )
												train_parser.add_argument(
												    "--extra-commit-description"       ,  type=snake_case__       ,  default=""       ,  help="Optional additional commit description to use when opening a PR (e.g. to tag the owner)."       ,  )
												train_parser.add_argument(
												    "--override-model-class"       ,  type=snake_case__       ,  default=snake_case__       ,  help="If you think you know better than the auto-detector, you can specify the model class here. "
												    "Can be either an AutoModel class or a specific model class like BertForSequenceClassification."       ,  )
												train_parser.set_defaults(func=snake_case__			)




						@staticmethod
						def 		UpperCAmelCase_       (   snake_case__       ,  snake_case__			):
												'''simple docstring'''
												lowercase__				:      str=       set(pt_outputs.keys()			)
												lowercase__				:      Dict=       set(tf_outputs.keys()			)
												if pt_out_attrs != tf_out_attrs:
																		raise ValueError(
																		    F'''The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:'''
																		    F''' {tf_out_attrs})'''			)

												# 2. For each output attribute, computes the difference
												def _find_pt_tf_differences(snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__=""			):
																		# If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
																		# recursivelly, keeping the name of the attribute.
																		if isinstance(snake_case__       ,  torch.Tensor			):
																								lowercase__				:      str=       np.max(np.abs(pt_out.numpy() - tf_out.numpy()			)			)
																								lowercase__				:      List[str]=       tensor_difference
																		else:
																								lowercase__				:      Optional[Any]=       attr_name
																								for i, pt_item in enumerate(snake_case__			):
																														# If it is a named attribute, we keep the name. Otherwise, just its index.
																														if isinstance(snake_case__       ,  snake_case__			):
																																				lowercase__				:      int=       root_name + pt_item
																																				lowercase__				:      Dict=       tf_out[pt_item]
																																				lowercase__				:      Union[str, Any]=       pt_out[pt_item]
																														else:
																																				lowercase__				:      Union[str, Any]=       root_name + F'''[{i}]'''
																																				lowercase__				:      Dict=       tf_out[i]
																														lowercase__				:      Union[str, Any]=       _find_pt_tf_differences(snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__			)

																		return differences

												return _find_pt_tf_differences(snake_case__       ,  snake_case__       ,  {}			)




						def __init__(   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  *snake_case__       ,  ):
												'''simple docstring'''
												lowercase__				:      Union[str, Any]=       logging.get_logger("transformers-cli/pt_to_tf"			)
												lowercase__				:      Optional[Any]=       model_name
												lowercase__				:      Any=       local_dir if local_dir else os.path.join("/tmp"       ,  snake_case__			)
												lowercase__				:      int=       max_error
												lowercase__				:      Optional[int]=       new_weights
												lowercase__				:      Any=       no_pr
												lowercase__				:      Dict=       push
												lowercase__				:      Optional[int]=       extra_commit_description
												lowercase__				:      str=       override_model_class




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__			):
												'''simple docstring'''

												def _get_audio_input():
																		lowercase__				:      Any=       load_dataset("hf-internal-testing/librispeech_asr_dummy"       ,  "clean"       ,  split="validation"			)
																		lowercase__				:      Any=       ds.sort("id"			).select(range(2			)			)[:2]["audio"]
																		lowercase__				:      List[Any]=       [x["array"] for x in speech_samples]
																		return raw_samples

												lowercase__				:      List[str]=       type(pt_model.config			)
												if model_config_class in PROCESSOR_MAPPING:
																		lowercase__				:      List[str]=       AutoProcessor.from_pretrained(self._local_dir			)
																		if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
																								lowercase__				:      int=       processor.tokenizer.eos_token
												elif model_config_class in IMAGE_PROCESSOR_MAPPING:
																		lowercase__				:      int=       AutoImageProcessor.from_pretrained(self._local_dir			)
												elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
																		lowercase__				:      Any=       AutoFeatureExtractor.from_pretrained(self._local_dir			)
												elif model_config_class in TOKENIZER_MAPPING:
																		lowercase__				:      Any=       AutoTokenizer.from_pretrained(self._local_dir			)
																		if processor.pad_token is None:
																								lowercase__				:      Tuple=       processor.eos_token
												else:
																		raise ValueError(F'''Unknown data processing type (model config type: {model_config_class})'''			)

												lowercase__				:      List[Any]=       set(inspect.signature(pt_model.forward			).parameters.keys()			)
												lowercase__				:      Any=       {}
												if "input_ids" in model_forward_signature:
																		processor_inputs.update(
																		    {
																		        "text": ["Hi there!", "I am a batch with more than one row and different input lengths."],
																		        "padding": True,
																		        "truncation": True,
																		    }			)
												if "pixel_values" in model_forward_signature:
																		lowercase__				:      List[Any]=       load_dataset("cifar10"       ,  "plain_text"       ,  split="test"			)[:2]["img"]
																		processor_inputs.update({"images": sample_images}			)
												if "input_features" in model_forward_signature:
																		lowercase__				:      Dict=       inspect.signature(processor.feature_extractor			).parameters
																		# Pad to the largest input length by default but take feature extractor default
																		# padding value if it exists e.g. "max_length" and is not False or None
																		if "padding" in feature_extractor_signature:
																								lowercase__				:      str=       feature_extractor_signature["padding"].default
																								if default_strategy is not False and default_strategy is not None:
																														lowercase__				:      Optional[Any]=       default_strategy
																								else:
																														lowercase__				:      Dict=       True
																		else:
																								lowercase__				:      Any=       True
																		processor_inputs.update({"audio": _get_audio_input(), "padding": padding_strategy}			)
												if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
																		processor_inputs.update({"audio": _get_audio_input(), "padding": True}			)
												lowercase__				:      int=       processor(**snake_case__       ,  return_tensors="pt"			)
												lowercase__				:      int=       processor(**snake_case__       ,  return_tensors="tf"			)

												# Extra input requirements, in addition to the input modality
												if (
												    config.is_encoder_decoder
												    or (hasattr(snake_case__       ,  "encoder"			) and hasattr(snake_case__       ,  "decoder"			))
												    or "decoder_input_ids" in tf_dummy_inputs
												):
																		lowercase__				:      List[Any]=       np.asarray([[1], [1]]       ,  dtype=snake_case__			) * (pt_model.config.decoder_start_token_id or 0)
																		pt_input.update({"decoder_input_ids": torch.tensor(snake_case__			)}			)
																		tf_input.update({"decoder_input_ids": tf.convert_to_tensor(snake_case__			)}			)

												return pt_input, tf_input




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												# hub version 0.9.0 introduced the possibility of programmatically opening PRs with normal write tokens.
												if version.parse(huggingface_hub.__version__			) < version.parse("0.9.0"			):
																		raise ImportError(
																		    "The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub"
																		    " installation."			)
												else:
																		from huggingface_hub import Repository, create_commit
																		from huggingface_hub._commit_api import CommitOperationAdd

												# Fetch remote data
												lowercase__				:      Optional[Any]=       Repository(local_dir=self._local_dir       ,  clone_from=self._model_name			)

												# Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
												lowercase__				:      List[str]=       AutoConfig.from_pretrained(self._local_dir			)
												lowercase__				:      List[str]=       config.architectures
												if self._override_model_class is not None:
																		if self._override_model_class.startswith("TF"			):
																								lowercase__				:      Optional[int]=       [self._override_model_class[2:]]
																		else:
																								lowercase__				:      Dict=       [self._override_model_class]
																		try:
																								lowercase__				:      Optional[Any]=       getattr(import_module("transformers"			)       ,  architectures[0]			)
																		except AttributeError:
																								raise ValueError(F'''Model class {self._override_model_class} not found in transformers.'''			)
																		try:
																								lowercase__				:      Union[str, Any]=       getattr(import_module("transformers"			)       ,  "TF" + architectures[0]			)
																		except AttributeError:
																								raise ValueError(F'''TF model class TF{self._override_model_class} not found in transformers.'''			)
												elif architectures is None:  # No architecture defined -- use auto classes
																		lowercase__				:      Tuple=       getattr(import_module("transformers"			)       ,  "AutoModel"			)
																		lowercase__				:      List[Any]=       getattr(import_module("transformers"			)       ,  "TFAutoModel"			)
																		self._logger.warning("No detected architecture, using AutoModel/TFAutoModel"			)
												else:  # Architecture defined -- use it
																		if len(snake_case__			) > 1:
																								raise ValueError(F'''More than one architecture was found, aborting. (architectures = {architectures})'''			)
																		self._logger.warning(F'''Detected architecture: {architectures[0]}'''			)
																		lowercase__				:      Tuple=       getattr(import_module("transformers"			)       ,  architectures[0]			)
																		try:
																								lowercase__				:      Any=       getattr(import_module("transformers"			)       ,  "TF" + architectures[0]			)
																		except AttributeError:
																								raise AttributeError(F'''The TensorFlow equivalent of {architectures[0]} doesn\'t exist in transformers.'''			)

        # Check the TF dummy inputs to see what keys we need in the forward pass
												lowercase__				:      List[str]=       tf_class.from_config(snake_case__			)
												lowercase__				:      Optional[Any]=       tf_from_pt_model.dummy_inputs

												del tf_from_pt_model  # Try to keep only one model in memory at a time

												# Load the model and get some basic inputs
												lowercase__				:      Dict=       pt_class.from_pretrained(self._local_dir			)
												pt_model.eval()

												lowercase__,	lowercase__				:      Union[str, Any]=       self.get_inputs(snake_case__       ,  snake_case__       ,  snake_case__			)

												with torch.no_grad():
																		lowercase__				:      int=       pt_model(**snake_case__       ,  output_hidden_states=snake_case__			)
												del pt_model  # will no longer be used, and may have a large memory footprint

												lowercase__				:      int=       tf_class.from_pretrained(self._local_dir       ,  from_pt=snake_case__			)
												lowercase__				:      Dict=       tf_from_pt_model(**snake_case__       ,  output_hidden_states=snake_case__       ,  training=snake_case__			)

												# Confirms that cross loading PT weights into TF worked.
												lowercase__				:      Tuple=       self.find_pt_tf_differences(snake_case__       ,  snake_case__			)
												lowercase__				:      Dict=       {k: v for k, v in crossload_differences.items() if "hidden" not in k}
												lowercase__				:      List[str]=       {k: v for k, v in crossload_differences.items() if "hidden" in k}
												if len(snake_case__			) == 0 and architectures is not None:
																		raise ValueError(
																		    F'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
																		    " output was found. All outputs start with 'hidden'"			)
												lowercase__				:      str=       max(output_differences.values()			) if output_differences else 0.0
												lowercase__				:      Optional[int]=       max(hidden_differences.values()			)
												if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
																		raise ValueError(
																		    "The cross-loaded TensorFlow model has different outputs, something went wrong!\n"
																		    + F'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
																		    + "\n".join([F'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]			)
																		    + F'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
																		    + "\n".join([F'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]			)			)

												# Save the weights in a TF format (if needed) and confirms that the results are still good
												lowercase__				:      Union[str, Any]=       os.path.join(self._local_dir       ,  snake_case__			)
												lowercase__				:      str=       os.path.join(self._local_dir       ,  snake_case__			)
												if (not os.path.exists(snake_case__			) and not os.path.exists(snake_case__			)) or self._new_weights:
																		tf_from_pt_model.save_pretrained(self._local_dir			)
												del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

												lowercase__				:      Union[str, Any]=       tf_class.from_pretrained(self._local_dir			)
												lowercase__				:      int=       tf_model(**snake_case__       ,  output_hidden_states=snake_case__			)

												lowercase__				:      Optional[int]=       self.find_pt_tf_differences(snake_case__       ,  snake_case__			)
												lowercase__				:      Optional[Any]=       {k: v for k, v in conversion_differences.items() if "hidden" not in k}
												lowercase__				:      int=       {k: v for k, v in conversion_differences.items() if "hidden" in k}
												if len(snake_case__			) == 0 and architectures is not None:
																		raise ValueError(
																		    F'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
																		    " output was found. All outputs start with 'hidden'"			)
												lowercase__				:      Tuple=       max(output_differences.values()			) if output_differences else 0.0
												lowercase__				:      Optional[Any]=       max(hidden_differences.values()			)
												if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
																		raise ValueError(
																		    "The converted TensorFlow model has different outputs, something went wrong!\n"
																		    + F'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
																		    + "\n".join([F'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]			)
																		    + F'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
																		    + "\n".join([F'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]			)			)

												lowercase__				:      Tuple=       "Update TF weights" if self._new_weights else "Add TF weights"
												if self._push:
																		repo.git_add(auto_lfs_track=snake_case__			)
																		repo.git_commit(snake_case__			)
																		repo.git_push(blocking=snake_case__			)  # this prints a progress bar with the upload
																		self._logger.warning(F'''TF weights pushed into {self._model_name}'''			)
												elif not self._no_pr:
																		self._logger.warning("Uploading the weights into a new PR..."			)
																		lowercase__				:      Any=       (
																		    "Model converted by the [`transformers`' `pt_to_tf`"
																		    " CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). "
																		    "All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n"
																		    F'''Maximum crossload output difference={max_crossload_output_diff:.3e}; '''
																		    F'''Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n'''
																		    F'''Maximum conversion output difference={max_conversion_output_diff:.3e}; '''
																		    F'''Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n'''
																		)
																		if self._max_error > MAX_ERROR:
																								commit_descrition += (
																								    F'''\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!'''
																								)
																		if self._extra_commit_description:
																								commit_descrition += "\n\n" + self._extra_commit_description

																		# sharded model -> adds all related files (index and .h5 shards)
																		if os.path.exists(snake_case__			):
																								lowercase__				:      int=       [
																								    CommitOperationAdd(path_in_repo=snake_case__       ,  path_or_fileobj=snake_case__			)
																								]
																								for shard_path in tf.io.gfile.glob(self._local_dir + "/tf_model-*.h5"			):
																														operations += [
																														    CommitOperationAdd(path_in_repo=os.path.basename(snake_case__			)       ,  path_or_fileobj=snake_case__			)
																														]
																		else:
																								lowercase__				:      Optional[Any]=       [CommitOperationAdd(path_in_repo=snake_case__       ,  path_or_fileobj=snake_case__			)]

																		lowercase__				:      Dict=       create_commit(
																		    repo_id=self._model_name       ,  operations=snake_case__       ,  commit_message=snake_case__       ,  commit_description=snake_case__       ,  repo_type="model"       ,  create_pr=snake_case__       ,  ).pr_url
																		self._logger.warning(F'''PR open in {hub_pr_url}'''			)









import unittest

import pytest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    MBartaaTokenizerFast,
    MBartConfig,
    MBartForConditionalGeneration,
    TranslationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch, slow

from .test_pipelines_common import ANY







@is_pipeline_test
class  __lowerCamelCase				(	unittest.TestCase	):
      lowerCamelCase_	:      Tuple          =					MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
      lowerCamelCase_	:      int          =					TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Any:
        if isinstance(model.config							,  lowerCamelCase   ):
          snake_case_						,				snake_case_       						=      list(tokenizer.lang_code_to_id.keys()   )[:2]
          snake_case_       						=      TranslationPipeline(model=lowerCamelCase							,  tokenizer=lowerCamelCase							,  src_lang=lowerCamelCase							,  tgt_lang=lowerCamelCase   )
        else:
          snake_case_       						=      TranslationPipeline(model=lowerCamelCase							,  tokenizer=lowerCamelCase   )
        return translator, ["Some string", "Some other text"]







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase   )						->       List[str]:
        snake_case_       						=      translator("""Some string"""   )
        self.assertEqual(lowerCamelCase							,  [{"""translation_text""": ANY(lowerCamelCase   )}]   )

        snake_case_       						=      translator(["""Some string"""]   )
        self.assertEqual(lowerCamelCase							,  [{"""translation_text""": ANY(lowerCamelCase   )}]   )

        snake_case_       						=      translator(["""Some string""", """other string"""]   )
        self.assertEqual(lowerCamelCase							,  [{"""translation_text""": ANY(lowerCamelCase   )}, {"""translation_text""": ANY(lowerCamelCase   )}]   )







      @require_torch
      def 	lowerCAmelCase_    (     self   )						->       List[Any]:
        snake_case_       						=      pipeline("""translation_en_to_ro"""							,  model="""patrickvonplaten/t5-tiny-random"""							,  framework="""pt"""   )
        snake_case_       						=      translator("""This is a test string"""							,  max_length=20   )
        self.assertEqual(
            lowerCamelCase							,  [
                {
                    """translation_text""": (
                        """Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"""
                        """ Beide Beide"""
                    )
                }
            ]							,  )







      @require_tf
      def 	lowerCAmelCase_    (     self   )						->       Optional[Any]:
        snake_case_       						=      pipeline("""translation_en_to_ro"""							,  model="""patrickvonplaten/t5-tiny-random"""							,  framework="""tf"""   )
        snake_case_       						=      translator("""This is a test string"""							,  max_length=20   )
        self.assertEqual(
            lowerCamelCase							,  [
                {
                    """translation_text""": (
                        """Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"""
                        """ Beide Beide"""
                    )
                }
            ]							,  )







      @require_torch
      def 	lowerCAmelCase_    (     self   )						->       Union[str, Any]:
        snake_case_       						=      pipeline("""translation_en_to_de"""							,  model="""patrickvonplaten/t5-tiny-random"""							,  framework="""pt"""   )
        snake_case_       						=      translator("""This is a test string"""							,  max_length=20   )
        self.assertEqual(
            lowerCamelCase							,  [
                {
                    """translation_text""": (
                        """monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"""
                        """ urine urine urine urine urine urine urine"""
                    )
                }
            ]							,  )







      @require_tf
      def 	lowerCAmelCase_    (     self   )						->       List[Any]:
        snake_case_       						=      pipeline("""translation_en_to_de"""							,  model="""patrickvonplaten/t5-tiny-random"""							,  framework="""tf"""   )
        snake_case_       						=      translator("""This is a test string"""							,  max_length=20   )
        self.assertEqual(
            lowerCamelCase							,  [
                {
                    """translation_text""": (
                        """monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"""
                        """ urine urine urine urine urine urine urine"""
                    )
                }
            ]							,  )







class  __lowerCamelCase				(	unittest.TestCase	):







      @require_torch
      @slow
      def 	lowerCAmelCase_    (     self   )						->       Tuple:
        # We don't provide a default for this pair
        with self.assertRaises(lowerCamelCase   ):
          pipeline(task="""translation_cn_to_ar"""   )

        # but we do for this one
        snake_case_       						=      pipeline(task="""translation_en_to_de"""   )
        self.assertEqual(translator._preprocess_params["""src_lang"""]							,  """en"""   )
        self.assertEqual(translator._preprocess_params["""tgt_lang"""]							,  """de"""   )







      @require_torch
      @slow
      def 	lowerCAmelCase_    (     self   )						->       int:
        snake_case_       						=      MBartForConditionalGeneration.from_pretrained("""facebook/mbart-large-50-many-to-many-mmt"""   )
        snake_case_       						=      MBartaaTokenizerFast.from_pretrained("""facebook/mbart-large-50-many-to-many-mmt"""   )

        snake_case_       						=      pipeline(task="""translation"""							,  model=lowerCamelCase							,  tokenizer=lowerCamelCase   )
        # Missing src_lang, tgt_lang
        with self.assertRaises(lowerCamelCase   ):
          translator("""This is a test"""   )

        snake_case_       						=      translator("""This is a test"""							,  src_lang="""en_XX"""							,  tgt_lang="""ar_AR"""   )
        self.assertEqual(lowerCamelCase							,  [{"""translation_text""": """هذا إختبار"""}]   )

        snake_case_       						=      translator("""This is a test"""							,  src_lang="""en_XX"""							,  tgt_lang="""hi_IN"""   )
        self.assertEqual(lowerCamelCase							,  [{"""translation_text""": """यह एक परीक्षण है"""}]   )

        # src_lang, tgt_lang can be defined at pipeline call time
        snake_case_       						=      pipeline(task="""translation"""							,  model=lowerCamelCase							,  tokenizer=lowerCamelCase							,  src_lang="""en_XX"""							,  tgt_lang="""ar_AR"""   )
        snake_case_       						=      translator("""This is a test"""   )
        self.assertEqual(lowerCamelCase							,  [{"""translation_text""": """هذا إختبار"""}]   )







      @require_torch
      def 	lowerCAmelCase_    (     self   )						->       int:
        snake_case_       						=      """patrickvonplaten/t5-tiny-random"""
        snake_case_       						=      pipeline(task="""translation_cn_to_ar"""							,  model=lowerCamelCase   )
        self.assertEqual(translator._preprocess_params["""src_lang"""]							,  """cn"""   )
        self.assertEqual(translator._preprocess_params["""tgt_lang"""]							,  """ar"""   )







      @require_torch
      def 	lowerCAmelCase_    (     self   )						->       List[str]:
        snake_case_       						=      """patrickvonplaten/t5-tiny-random"""
        with pytest.warns(lowerCamelCase							,  match=r""".*translation_en_to_de.*"""   ):
          snake_case_       						=      pipeline(task="""translation"""							,  model=lowerCamelCase   )
        self.assertEqual(translator.task							,  """translation_en_to_de"""   )
        self.assertEqual(translator._preprocess_params["""src_lang"""]							,  """en"""   )
        self.assertEqual(translator._preprocess_params["""tgt_lang"""]							,  """de"""   )







      @require_torch
      def 	lowerCAmelCase_    (     self   )						->       Any:
        with self.assertRaises(lowerCamelCase   ):
          pipeline(task="""translation"""   )