





'''simple docstring'''




import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY


@is_pipeline_test
@require_torch_or_tf
class  SCREAMING_SNAKE_CASE    (unittest.TestCase							):
     lowerCAmelCase					=       MODEL_FOR_CAUSAL_LM_MAPPING
     lowerCAmelCase					=       TF_MODEL_FOR_CAUSAL_LM_MAPPING


     @require_torch
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Tuple      =       pipeline(task='text-generation'						,	model='sshleifer/tiny-ctrl'						,	framework='pt')
          # Using `do_sample=False` to force deterministic output
          __A						: Union[str, Any]      =       text_generator('This is a test'						,	do_sample=_UpperCAmelCase)
          self.assertEqual(
              _UpperCAmelCase						,	[
                  {
                      'generated_text': (
                          'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
                          ' oscope. FiliFili@@'
                      )
                  }
              ]						,	)

          __A						: List[str]      =       text_generator(['This is a test', 'This is a second test'])
          self.assertEqual(
              _UpperCAmelCase						,	[
                  [
                      {
                          'generated_text': (
                              'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
                              ' oscope. FiliFili@@'
                          )
                      }
                  ],
                  [
                      {
                          'generated_text': (
                              'This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy'
                              ' oscope. oscope. FiliFili@@'
                          )
                      }
                  ],
              ]						,	)

          __A						: Union[str, Any]      =       text_generator('This is a test'						,	do_sample=_UpperCAmelCase						,	num_return_sequences=2						,	return_tensors=_UpperCAmelCase)
          self.assertEqual(
              _UpperCAmelCase						,	[
                  {'generated_token_ids': ANY(_UpperCAmelCase)},
                  {'generated_token_ids': ANY(_UpperCAmelCase)},
              ]						,	)
          __A						: int      =       text_generator.model.config.eos_token_id
          __A						: Dict      =       '<pad>'
          __A						: Any      =       text_generator(
              ['This is a test', 'This is a second test']						,	do_sample=_UpperCAmelCase						,	num_return_sequences=2						,	batch_size=2						,	return_tensors=_UpperCAmelCase						,	)
          self.assertEqual(
              _UpperCAmelCase						,	[
                  [
                      {'generated_token_ids': ANY(_UpperCAmelCase)},
                      {'generated_token_ids': ANY(_UpperCAmelCase)},
                  ],
                  [
                      {'generated_token_ids': ANY(_UpperCAmelCase)},
                      {'generated_token_ids': ANY(_UpperCAmelCase)},
                  ],
              ]						,	)


     @require_tf
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Any      =       pipeline(task='text-generation'						,	model='sshleifer/tiny-ctrl'						,	framework='tf')

          # Using `do_sample=False` to force deterministic output
          __A						: str      =       text_generator('This is a test'						,	do_sample=_UpperCAmelCase)
          self.assertEqual(
              _UpperCAmelCase						,	[
                  {
                      'generated_text': (
                          'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
                          ' please,'
                      )
                  }
              ]						,	)

          __A						: List[Any]      =       text_generator(['This is a test', 'This is a second test']						,	do_sample=_UpperCAmelCase)
          self.assertEqual(
              _UpperCAmelCase						,	[
                  [
                      {
                          'generated_text': (
                              'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
                              ' please,'
                          )
                      }
                  ],
                  [
                      {
                          'generated_text': (
                              'This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes'
                              ' Cannes 閲閲Cannes Cannes Cannes 攵 please,'
                          )
                      }
                  ],
              ]						,	)


     def 							SCREAMING_SNAKE_CASE  (						self						,	_UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase):

          '''simple docstring'''






          __A						: Tuple      =       TextGenerationPipeline(model=_UpperCAmelCase						,	tokenizer=_UpperCAmelCase)
          return text_generator, ["This is a test", "Another test"]


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: List[str]      =       'Hello I believe in'
          __A						: Any      =       pipeline('text-generation'						,	model='hf-internal-testing/tiny-random-gpt2')
          __A						: List[Any]      =       text_generator(_UpperCAmelCase)
          self.assertEqual(
              _UpperCAmelCase						,	[{'generated_text': 'Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'}]						,	)

          __A						: int      =       text_generator(_UpperCAmelCase						,	stop_sequence=' fe')
          self.assertEqual(_UpperCAmelCase						,	[{'generated_text': 'Hello I believe in fe'}])


     def 							SCREAMING_SNAKE_CASE  (						self						,	_UpperCAmelCase						,	_UpperCAmelCase):

          '''simple docstring'''






          __A						: int      =       text_generator.model
          __A						: List[str]      =       text_generator.tokenizer

          __A						: Union[str, Any]      =       text_generator('This is a test')
          self.assertEqual(_UpperCAmelCase						,	[{'generated_text': ANY(_UpperCAmelCase)}])
          self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'))

          __A						: str      =       text_generator('This is a test'						,	return_full_text=_UpperCAmelCase)
          self.assertEqual(_UpperCAmelCase						,	[{'generated_text': ANY(_UpperCAmelCase)}])
          self.assertNotIn('This is a test'						,	outputs[0]['generated_text'])

          __A						: Dict      =       pipeline(task='text-generation'						,	model=_UpperCAmelCase						,	tokenizer=_UpperCAmelCase						,	return_full_text=_UpperCAmelCase)
          __A						: Dict      =       text_generator('This is a test')
          self.assertEqual(_UpperCAmelCase						,	[{'generated_text': ANY(_UpperCAmelCase)}])
          self.assertNotIn('This is a test'						,	outputs[0]['generated_text'])

          __A						: Optional[Any]      =       text_generator('This is a test'						,	return_full_text=_UpperCAmelCase)
          self.assertEqual(_UpperCAmelCase						,	[{'generated_text': ANY(_UpperCAmelCase)}])
          self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'))

          __A						: int      =       text_generator(['This is great !', 'Something else']						,	num_return_sequences=2						,	do_sample=_UpperCAmelCase)
          self.assertEqual(
              _UpperCAmelCase						,	[
                  [{'generated_text': ANY(_UpperCAmelCase)}, {'generated_text': ANY(_UpperCAmelCase)}],
                  [{'generated_text': ANY(_UpperCAmelCase)}, {'generated_text': ANY(_UpperCAmelCase)}],
              ]						,	)

          if text_generator.tokenizer.pad_token is not None:
               __A						: str      =       text_generator(
                   ['This is great !', 'Something else']						,	num_return_sequences=2						,	batch_size=2						,	do_sample=_UpperCAmelCase)
               self.assertEqual(
                   _UpperCAmelCase						,	[
                       [{'generated_text': ANY(_UpperCAmelCase)}, {'generated_text': ANY(_UpperCAmelCase)}],
                       [{'generated_text': ANY(_UpperCAmelCase)}, {'generated_text': ANY(_UpperCAmelCase)}],
                   ]						,	)

          with self.assertRaises(_UpperCAmelCase):
               __A						: Tuple      =       text_generator('test'						,	return_full_text=_UpperCAmelCase						,	return_text=_UpperCAmelCase)
          with self.assertRaises(_UpperCAmelCase):
               __A						: Dict      =       text_generator('test'						,	return_full_text=_UpperCAmelCase						,	return_tensors=_UpperCAmelCase)
          with self.assertRaises(_UpperCAmelCase):
               __A						: List[Any]      =       text_generator('test'						,	return_text=_UpperCAmelCase						,	return_tensors=_UpperCAmelCase)

          # Empty prompt is slighly special
          # it requires BOS token to exist.
          # Special case for Pegasus which will always append EOS so will
          # work even without BOS.
          if (
              text_generator.tokenizer.bos_token_id is not None
              or "Pegasus" in tokenizer.__class__.__name__
              or "Git" in model.__class__.__name__
          ):
               __A						: Optional[int]      =       text_generator('')
               self.assertEqual(_UpperCAmelCase						,	[{'generated_text': ANY(_UpperCAmelCase)}])
          else:
               with self.assertRaises((ValueError, AssertionError)):
                    __A						: List[Any]      =       text_generator('')

          if text_generator.framework == "tf":
               # TF generation does not support max_new_tokens, and it's impossible
               # to control long generation with only max_length without
               # fancy calculation, dismissing tests for now.
               return
          # We don't care about infinite range models.
          # They already work.
          # Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
          __A						: Any      =       ['RwkvForCausalLM', 'XGLMForCausalLM', 'GPTNeoXForCausalLM']
          if (
              tokenizer.model_max_length < 1_0000
              and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
          ):
               # Handling of large generations
               with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)):
                    text_generator('This is a test' * 500						,	max_new_tokens=20)

               __A						: Dict      =       text_generator('This is a test' * 500						,	handle_long_generation='hole'						,	max_new_tokens=20)
               # Hole strategy cannot work
               with self.assertRaises(_UpperCAmelCase):
                    text_generator(
                        'This is a test' * 500						,	handle_long_generation='hole'						,	max_new_tokens=tokenizer.model_max_length + 10						,	)


     @require_torch
     @require_accelerate
     @require_torch_gpu
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          import torch

          # Classic `model_kwargs`
          __A						: Tuple      =       pipeline(
              model='hf-internal-testing/tiny-random-bloom'						,	model_kwargs={'device_map': 'auto', 'torch_dtype': torch.bfloataa}						,	)
          self.assertEqual(pipe.model.device						,	torch.device(0))
          self.assertEqual(pipe.model.lm_head.weight.dtype						,	torch.bfloataa)
          __A						: Optional[Any]      =       pipe('This is a test')
          self.assertEqual(
              _UpperCAmelCase						,	[
                  {
                      'generated_text': (
                          'This is a test test test test test test test test test test test test test test test test'
                          ' test'
                      )
                  }
              ]						,	)

          # Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
          __A						: Tuple      =       pipeline(model='hf-internal-testing/tiny-random-bloom'						,	device_map='auto'						,	torch_dtype=torch.bfloataa)
          self.assertEqual(pipe.model.device						,	torch.device(0))
          self.assertEqual(pipe.model.lm_head.weight.dtype						,	torch.bfloataa)
          __A						: Any      =       pipe('This is a test')
          self.assertEqual(
              _UpperCAmelCase						,	[
                  {
                      'generated_text': (
                          'This is a test test test test test test test test test test test test test test test test'
                          ' test'
                      )
                  }
              ]						,	)

          # torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
          __A						: Optional[Any]      =       pipeline(model='hf-internal-testing/tiny-random-bloom'						,	device_map='auto')
          self.assertEqual(pipe.model.device						,	torch.device(0))
          self.assertEqual(pipe.model.lm_head.weight.dtype						,	torch.floataa)
          __A						: Tuple      =       pipe('This is a test')
          self.assertEqual(
              _UpperCAmelCase						,	[
                  {
                      'generated_text': (
                          'This is a test test test test test test test test test test test test test test test test'
                          ' test'
                      )
                  }
              ]						,	)


     @require_torch
     @require_torch_gpu
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          import torch

          __A						: Any      =       pipeline(model='hf-internal-testing/tiny-random-bloom'						,	device=0						,	torch_dtype=torch.floataa)
          pipe('This is a test')


     @require_torch
     @require_accelerate
     @require_torch_gpu
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          import torch

          __A						: Tuple      =       pipeline(model='hf-internal-testing/tiny-random-bloom'						,	device_map='auto'						,	torch_dtype=torch.floataa)
          pipe('This is a test'						,	do_sample=_UpperCAmelCase						,	top_p=0.5)


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Union[str, Any]      =       'Hello world'
          __A						: str      =       pipeline('text-generation'						,	model='hf-internal-testing/tiny-random-gpt2')
          if text_generator.model.framework == "tf":
               __A						: Union[str, Any]      =       logging.get_logger('transformers.generation.tf_utils')
          else:
               __A						: Optional[int]      =       logging.get_logger('transformers.generation.utils')
          __A						: Any      =       'Both `max_new_tokens`'  # The beggining of the message to be checked in this test

          # Both are set by the user -> log warning
          with CaptureLogger(_UpperCAmelCase) as cl:
               __A						: Any      =       text_generator(_UpperCAmelCase						,	max_length=10						,	max_new_tokens=1)
          self.assertIn(_UpperCAmelCase						,	cl.out)

          # The user only sets one -> no warning
          with CaptureLogger(_UpperCAmelCase) as cl:
               __A						: List[str]      =       text_generator(_UpperCAmelCase						,	max_new_tokens=1)
          self.assertNotIn(_UpperCAmelCase						,	cl.out)

          with CaptureLogger(_UpperCAmelCase) as cl:
               __A						: List[Any]      =       text_generator(_UpperCAmelCase						,	max_length=10)
          self.assertNotIn(_UpperCAmelCase						,	cl.out)






'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase__    :      List[str]						=    {
    '''configuration_git''': ['''GIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GitConfig''', '''GitVisionConfig'''],
    '''processing_git''': ['''GitProcessor'''],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase__    :      Any						=    [
      '''GIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''GitForCausalLM''',
      '''GitModel''',
      '''GitPreTrainedModel''',
      '''GitVisionModel''',
  ]

if TYPE_CHECKING:
  from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
  from .processing_git import GitProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_git import (
        GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
        GitForCausalLM,
        GitModel,
        GitPreTrainedModel,
        GitVisionModel,
    )

else:
  import sys

  lowercase__    :      List[str]						=    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)