
"""simple docstring"""





from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
    import tensorflow as tf


_a		       =							logging.get_logger(__name__)


@dataclass
class A_	(lowercase__      ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__			:						List[Any]       =		[
      """no_inference""",
      """no_cuda""",
      """no_tpu""",
      """no_speed""",
      """no_memory""",
      """no_env_print""",
      """no_multi_process""",
  ]







  def __init__(		self				,   **lowercase_  ):

     """simple docstring"""
     for deprecated_arg in self.deprecated_args:
        if deprecated_arg in kwargs:
           UpperCAmelCase_					:					Tuple			     =    deprecated_arg[3:]
           UpperCAmelCase_					:					Any			     =    not kwargs.pop(lowercase_  )
           logger.warning(
               F"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
               F""" {positive_arg}={kwargs[positive_arg]}"""  )
     UpperCAmelCase_					:					List[Any]			     =    kwargs.pop("tpu_name"				,   self.tpu_name  )
     UpperCAmelCase_					:					Dict			     =    kwargs.pop("device_idx"				,   self.device_idx  )
     UpperCAmelCase_					:					Optional[int]			     =    kwargs.pop("eager_mode"				,   self.eager_mode  )
     UpperCAmelCase_					:					str			     =    kwargs.pop("use_xla"				,   self.use_xla  )
     super().__init__(**lowercase_  )

  SCREAMING_SNAKE_CASE__			:						str       =		field(
      default=lowercase__				,metadata={"""help""": """Name of TPU"""}				,)
  SCREAMING_SNAKE_CASE__			:						int       =		field(
      default=0				,metadata={"""help""": """CPU / GPU device index. Defaults to 0."""}				,)
  SCREAMING_SNAKE_CASE__			:						bool       =		field(default=lowercase__				,metadata={"""help""": """Benchmark models in eager model."""}      )
  SCREAMING_SNAKE_CASE__			:						bool       =		field(
      default=lowercase__				,metadata={
          """help""": """Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`."""
      }				,)







  @cached_property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     requires_backends(self				,   ["tf"]  )
     UpperCAmelCase_					:					Optional[int]			     =    None
     if self.tpu:
        try:
           if self.tpu_name:
              UpperCAmelCase_					:					Optional[int]			     =    tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name  )
           else:
              UpperCAmelCase_					:					str			     =    tf.distribute.cluster_resolver.TPUClusterResolver()
        except ValueError:
           UpperCAmelCase_					:					Dict			     =    None
     return tpu







  @cached_property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     requires_backends(self				,   ["tf"]  )
     if self.is_tpu:
        tf.config.experimental_connect_to_cluster(self._setup_tpu  )
        tf.tpu.experimental.initialize_tpu_system(self._setup_tpu  )

        UpperCAmelCase_					:					List[Any]			     =    tf.distribute.TPUStrategy(self._setup_tpu  )
     else:
        # currently no multi gpu is allowed
        if self.is_gpu:
           # TODO: Currently only single GPU is supported
           tf.config.set_visible_devices(self.gpu_list[self.device_idx]				,   "GPU"  )
           UpperCAmelCase_					:					str			     =    tf.distribute.OneDeviceStrategy(device=F"""/gpu:{self.device_idx}"""  )
        else:
           tf.config.set_visible_devices([]				,   "GPU"  )  # disable GPU
           UpperCAmelCase_					:					Union[str, Any]			     =    tf.distribute.OneDeviceStrategy(device=F"""/cpu:{self.device_idx}"""  )

     return strategy







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     requires_backends(self				,   ["tf"]  )
     return self._setup_tpu is not None







  @property
  def        UpperCamelCase__					(		self  ):

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







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     requires_backends(self				,   ["tf"]  )
     return tf.config.list_physical_devices("GPU"  )







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     requires_backends(self				,   ["tf"]  )
     if self.cuda:
        return len(self.gpu_list  )
     return 0







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     return self.n_gpu > 0





import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TextaTextGenerationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch
from transformers.utils import is_torch_available

from .test_pipelines_common import ANY


if is_torch_available():
						import torch



@is_pipeline_test
class   __lowercase				( unittest.TestCase	):




			"""simple docstring"""







			_UpperCAmelCase   :							List[Any]										=     MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
			_UpperCAmelCase   :							str										=     TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING



			def        _SCREAMING_SNAKE_CASE			( self  :     Any   ,						lowerCAmelCase__  :     List[str]   ,						lowerCAmelCase__  :     List[str]   ,						lowerCAmelCase__  :     Dict):
									SCREAMING_SNAKE_CASE_: Any  		=       TextaTextGenerationPipeline(model=lowerCAmelCase__   ,						tokenizer=lowerCAmelCase__)
									return generator, ["Something to write", "Something else"]



			def        _SCREAMING_SNAKE_CASE			( self  :     str   ,						lowerCAmelCase__  :     Dict   ,						lowerCAmelCase__  :     Any):
									SCREAMING_SNAKE_CASE_: List[Any]  		=       generator("Something there")
									self.assertEqual(lowerCAmelCase__   ,						[{"generated_text": ANY(lowerCAmelCase__)}])
									# These are encoder decoder, they don't just append to incoming string
									self.assertFalse(outputs[0]["generated_text"].startswith("Something there"))

									SCREAMING_SNAKE_CASE_: List[Any]  		=       generator(["This is great !", "Something else"]   ,						num_return_sequences=2   ,						do_sample=lowerCAmelCase__)
									self.assertEqual(
									    lowerCAmelCase__   ,						[
									        [{"generated_text": ANY(lowerCAmelCase__)}, {"generated_text": ANY(lowerCAmelCase__)}],
									        [{"generated_text": ANY(lowerCAmelCase__)}, {"generated_text": ANY(lowerCAmelCase__)}],
									    ]   ,						)

									SCREAMING_SNAKE_CASE_: Dict  		=       generator(
									    ["This is great !", "Something else"]   ,						num_return_sequences=2   ,						batch_size=2   ,						do_sample=lowerCAmelCase__)
									self.assertEqual(
									    lowerCAmelCase__   ,						[
									        [{"generated_text": ANY(lowerCAmelCase__)}, {"generated_text": ANY(lowerCAmelCase__)}],
									        [{"generated_text": ANY(lowerCAmelCase__)}, {"generated_text": ANY(lowerCAmelCase__)}],
									    ]   ,						)

									with self.assertRaises(lowerCAmelCase__):
															generator(4)



			@require_torch
			def        _SCREAMING_SNAKE_CASE			( self  :     Tuple):
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       pipeline("text2text-generation"   ,						model="patrickvonplaten/t5-tiny-random"   ,						framework="pt")
									# do_sample=False necessary for reproducibility
									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       generator("Something there"   ,						do_sample=lowerCAmelCase__)
									self.assertEqual(lowerCAmelCase__   ,						[{"generated_text": ""}])

									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       3
									SCREAMING_SNAKE_CASE_: Any  		=       generator(
									    "Something there"   ,						num_return_sequences=lowerCAmelCase__   ,						num_beams=lowerCAmelCase__   ,						)
									SCREAMING_SNAKE_CASE_: Any  		=       [
									    {"generated_text": "Beide Beide Beide Beide Beide Beide Beide Beide Beide"},
									    {"generated_text": "Beide Beide Beide Beide Beide Beide Beide Beide"},
									    {"generated_text": ""},
									]
									self.assertEqual(lowerCAmelCase__   ,						lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_: int  		=       generator("This is a test"   ,						do_sample=lowerCAmelCase__   ,						num_return_sequences=2   ,						return_tensors=lowerCAmelCase__)
									self.assertEqual(
									    lowerCAmelCase__   ,						[
									        {"generated_token_ids": ANY(torch.Tensor)},
									        {"generated_token_ids": ANY(torch.Tensor)},
									    ]   ,						)
									SCREAMING_SNAKE_CASE_: str  		=       generator.model.config.eos_token_id
									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       "<pad>"
									SCREAMING_SNAKE_CASE_: Tuple  		=       generator(
									    ["This is a test", "This is a second test"]   ,						do_sample=lowerCAmelCase__   ,						num_return_sequences=2   ,						batch_size=2   ,						return_tensors=lowerCAmelCase__   ,						)
									self.assertEqual(
									    lowerCAmelCase__   ,						[
									        [
									            {"generated_token_ids": ANY(torch.Tensor)},
									            {"generated_token_ids": ANY(torch.Tensor)},
									        ],
									        [
									            {"generated_token_ids": ANY(torch.Tensor)},
									            {"generated_token_ids": ANY(torch.Tensor)},
									        ],
									    ]   ,						)




			@require_tf
			def        _SCREAMING_SNAKE_CASE			( self  :     Union[str, Any]):
									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       pipeline("text2text-generation"   ,						model="patrickvonplaten/t5-tiny-random"   ,						framework="tf")
									# do_sample=False necessary for reproducibility
									SCREAMING_SNAKE_CASE_: List[Any]  		=       generator("Something there"   ,						do_sample=lowerCAmelCase__)
									self.assertEqual(lowerCAmelCase__   ,						[{"generated_text": ""}])






