

'''simple docstring'''
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      a__						(							unittest.TestCase						):
   _SCREAMING_SNAKE_CASE					:  Any			 =							MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
   _SCREAMING_SNAKE_CASE					:  int			 =							TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase    ,       _UpperCamelCase						):





      """simple docstring"""





      if isinstance(model.config    ,       _UpperCamelCase						):
         _lowercase  ,   _lowercase    :   Optional[Any]      =     list(tokenizer.lang_code_to_id.keys()						)[:2]
         _lowercase    :   Optional[Any]      =     TranslationPipeline(model=_UpperCamelCase    ,       tokenizer=_UpperCamelCase    ,       src_lang=_UpperCamelCase    ,       tgt_lang=_UpperCamelCase						)
      else:
         _lowercase    :   Optional[int]      =     TranslationPipeline(model=_UpperCamelCase    ,       tokenizer=_UpperCamelCase						)
      return translator, ["Some string", "Some other text"]


   def 		_lowerCamelCase     (				self    ,       _UpperCamelCase    ,       _UpperCamelCase						):





      """simple docstring"""





      _lowercase    :   Dict      =     translator("Some string"						)
      self.assertEqual(_UpperCamelCase    ,       [{"translation_text": ANY(_UpperCamelCase						)}]						)

      _lowercase    :   List[Any]      =     translator(["Some string"]						)
      self.assertEqual(_UpperCamelCase    ,       [{"translation_text": ANY(_UpperCamelCase						)}]						)

      _lowercase    :   List[str]      =     translator(["Some string", "other string"]						)
      self.assertEqual(_UpperCamelCase    ,       [{"translation_text": ANY(_UpperCamelCase						)}, {"translation_text": ANY(_UpperCamelCase						)}]						)


   @require_torch
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   List[str]      =     pipeline("translation_en_to_ro"    ,       model="patrickvonplaten/t5-tiny-random"    ,       framework="pt"						)
      _lowercase    :   Tuple      =     translator("This is a test string"    ,       max_length=20						)
      self.assertEqual(
          _UpperCamelCase    ,       [
              {
                  "translation_text": (
                      "Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"
                      " Beide Beide"
                  )
              }
          ]    ,       )


   @require_tf
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   str      =     pipeline("translation_en_to_ro"    ,       model="patrickvonplaten/t5-tiny-random"    ,       framework="tf"						)
      _lowercase    :   Union[str, Any]      =     translator("This is a test string"    ,       max_length=20						)
      self.assertEqual(
          _UpperCamelCase    ,       [
              {
                  "translation_text": (
                      "Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"
                      " Beide Beide"
                  )
              }
          ]    ,       )


   @require_torch
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Tuple      =     pipeline("translation_en_to_de"    ,       model="patrickvonplaten/t5-tiny-random"    ,       framework="pt"						)
      _lowercase    :   List[str]      =     translator("This is a test string"    ,       max_length=20						)
      self.assertEqual(
          _UpperCamelCase    ,       [
              {
                  "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						):





      """simple docstring"""





      _lowercase    :   List[str]      =     pipeline("translation_en_to_de"    ,       model="patrickvonplaten/t5-tiny-random"    ,       framework="tf"						)
      _lowercase    :   List[str]      =     translator("This is a test string"    ,       max_length=20						)
      self.assertEqual(
          _UpperCamelCase    ,       [
              {
                  "translation_text": (
                      "monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"
                      " urine urine urine urine urine urine urine"
                  )
              }
          ]    ,       )




class      a__						(							unittest.TestCase						):


   @require_torch
   @slow
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      with self.assertRaises(_UpperCamelCase						):
         pipeline(task="translation_cn_to_ar"						)

      # but we do for this one
      _lowercase    :   Optional[int]      =     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						):





      """simple docstring"""





      _lowercase    :   List[Any]      =     MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-50-many-to-many-mmt"						)
      _lowercase    :   Dict      =     MBartaaTokenizerFast.from_pretrained("facebook/mbart-large-50-many-to-many-mmt"						)

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

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

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

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


   @require_torch
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   List[Any]      =     "patrickvonplaten/t5-tiny-random"
      _lowercase    :   List[Any]      =     pipeline(task="translation_cn_to_ar"    ,       model=_UpperCamelCase						)
      self.assertEqual(translator._preprocess_params["src_lang"]    ,       "cn"						)
      self.assertEqual(translator._preprocess_params["tgt_lang"]    ,       "ar"						)


   @require_torch
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      _lowercase    :   Any      =     "patrickvonplaten/t5-tiny-random"
      with pytest.warns(_UpperCamelCase    ,       match=R".*translation_en_to_de.*"						):
         _lowercase    :   Tuple      =     pipeline(task="translation"    ,       model=_UpperCamelCase						)
      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						):





      """simple docstring"""





      with self.assertRaises(_UpperCamelCase						):
         pipeline(task="translation"						)









'''simple docstring'''
import warnings
from dataclasses import dataclass, field
from typing import Optional, Tuple

from .training_args import TrainingArguments
from .utils import cached_property, is_tf_available, logging, requires_backends


_snake_case     						=						logging.get_logger(__name__)

if is_tf_available():
    import tensorflow as tf


@dataclass
class      a__						(							lowerCamelCase_						):
   _SCREAMING_SNAKE_CASE					:  int			 =							'tf'
   _SCREAMING_SNAKE_CASE					:  Optional[str]			 =							field(
       default=lowerCamelCase_						,   metadata={'help': 'Name of TPU'}						,   )

   _SCREAMING_SNAKE_CASE					:  Optional[str]			 =							field(
       default=lowerCamelCase_						,   metadata={'help': 'Zone of TPU'}						,   )

   _SCREAMING_SNAKE_CASE					:  Optional[str]			 =							field(
       default=lowerCamelCase_						,   metadata={'help': 'Name of Cloud TPU-enabled project'}						,   )

   _SCREAMING_SNAKE_CASE					:  float			 =							field(
       default=1.0						,   metadata={'help': 'Power for the Polynomial decay LR scheduler.'}						,   )

   _SCREAMING_SNAKE_CASE					:  bool			 =							field(default=lowerCamelCase_						,   metadata={'help': 'Whether to activate the XLA compilation or not'}						)


   @cached_property
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      requires_backends(self    ,       ["tf"]						)
      logger.info("Tensorflow: setting up strategy"						)

      _lowercase    :   Optional[int]      =     tf.config.list_physical_devices("GPU"						)

      # Set to float16 at first
      if self.fpaa:
         tf.keras.mixed_precision.set_global_policy("mixed_float16"						)

      if self.no_cuda:
         _lowercase    :   Optional[int]      =     tf.distribute.OneDeviceStrategy(device="/cpu:0"						)
      else:
         try:
            if self.tpu_name:
               _lowercase    :   int      =     tf.distribute.cluster_resolver.TPUClusterResolver(
                   self.tpu_name    ,       zone=self.tpu_zone    ,       project=self.gcp_project						)
            else:
               _lowercase    :   Any      =     tf.distribute.cluster_resolver.TPUClusterResolver()
         except ValueError:
            if self.tpu_name:
               raise RuntimeError(f'''Couldn\'t connect to TPU {self.tpu_name}!'''						)
            else:
               _lowercase    :   Tuple      =     None

         if tpu:
            # Set to bfloat16 in case of TPU
            if self.fpaa:
               tf.keras.mixed_precision.set_global_policy("mixed_bfloat16"						)

            tf.config.experimental_connect_to_cluster(_UpperCamelCase						)
            tf.tpu.experimental.initialize_tpu_system(_UpperCamelCase						)

            _lowercase    :   List[str]      =     tf.distribute.TPUStrategy(_UpperCamelCase						)

         elif len(_UpperCamelCase						) == 0:
            _lowercase    :   Optional[Any]      =     tf.distribute.OneDeviceStrategy(device="/cpu:0"						)
         elif len(_UpperCamelCase						) == 1:
            _lowercase    :   Optional[int]      =     tf.distribute.OneDeviceStrategy(device="/gpu:0"						)
         elif len(_UpperCamelCase						) > 1:
            # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
            _lowercase    :   Any      =     tf.distribute.MirroredStrategy()
         else:
            raise ValueError("Cannot find the proper strategy, please check your environment properties."						)

      return strategy


   @property
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      requires_backends(self    ,       ["tf"]						)
      return self._setup_strategy


   @property
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      requires_backends(self    ,       ["tf"]						)
      return self._setup_strategy.num_replicas_in_sync


   @property
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      return False  # TF Logging is handled by Keras not the Trainer


   @property
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      if self.per_gpu_train_batch_size:
         logger.warning(
             "Using deprecated `--per_gpu_train_batch_size` argument which will be removed in a future "
             "version. Using `--per_device_train_batch_size` is preferred."						)
      _lowercase    :   str      =     self.per_gpu_train_batch_size or self.per_device_train_batch_size
      return per_device_batch_size * self.n_replicas


   @property
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      if self.per_gpu_eval_batch_size:
         logger.warning(
             "Using deprecated `--per_gpu_eval_batch_size` argument which will be removed in a future "
             "version. Using `--per_device_eval_batch_size` is preferred."						)
      _lowercase    :   List[Any]      =     self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
      return per_device_batch_size * self.n_replicas






   @property
   def 		_lowerCamelCase     (				self						):





      """simple docstring"""





      requires_backends(self    ,       ["tf"]						)
      warnings.warn(
          "The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead."    ,       _UpperCamelCase    ,       )
      return self._setup_strategy.num_replicas_in_sync






