


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 _lowerCamelCase(						unittest.TestCase   ):
       lowercase_ :	Tuple     =			MODEL_FOR_CAUSAL_LM_MAPPING
       lowercase_ :	Any     =			TF_MODEL_FOR_CAUSAL_LM_MAPPING
       @require_torch
       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

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

           _lowercase       :							int      		=		text_generator(['This is a test', 'This is a second test'])
           self.assertEqual(
               lowerCamelCase,      [
                   [
                       {
                           '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@@'
                           )
                       }
                   ],
               ],      )

           _lowercase       :							List[Any]      		=		text_generator('This is a test',      do_sample=lowerCamelCase,      num_return_sequences=2,      return_tensors=lowerCamelCase)
           self.assertEqual(
               lowerCamelCase,      [
                   {'generated_token_ids': ANY(lowerCamelCase)},
                   {'generated_token_ids': ANY(lowerCamelCase)},
               ],      )
           _lowercase       :							Any      		=		text_generator.model.config.eos_token_id
           _lowercase       :							Union[str, Any]      		=		'<pad>'
           _lowercase       :							List[str]      		=		text_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(lowerCamelCase)},
                       {'generated_token_ids': ANY(lowerCamelCase)},
                   ],
                   [
                       {'generated_token_ids': ANY(lowerCamelCase)},
                       {'generated_token_ids': ANY(lowerCamelCase)},
                   ],
               ],      )
       @require_tf
       def 			UpperCamelCase     (					self)       ->   Dict:




           """simple docstring"""

           _lowercase       :							List[Any]      		=		pipeline(task='text-generation',      model='sshleifer/tiny-ctrl',      framework='tf')

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

           _lowercase       :							Dict      		=		text_generator(['This is a test', 'This is a second test'],      do_sample=lowerCamelCase)
           self.assertEqual(
               lowerCamelCase,      [
                   [
                       {
                           '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 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Dict:




           """simple docstring"""

           _lowercase       :							str      		=		TextGenerationPipeline(model=lowerCamelCase,      tokenizer=lowerCamelCase)
           return text_generator, ["This is a test", "Another test"]
       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

           _lowercase       :							Optional[int]      		=		'Hello I believe in'
           _lowercase       :							Optional[int]      		=		pipeline('text-generation',      model='hf-internal-testing/tiny-random-gpt2')
           _lowercase       :							int      		=		text_generator(lowerCamelCase)
           self.assertEqual(
               lowerCamelCase,      [{'generated_text': 'Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'}],      )

           _lowercase       :							Optional[int]      		=		text_generator(lowerCamelCase,      stop_sequence=' fe')
           self.assertEqual(lowerCamelCase,      [{'generated_text': 'Hello I believe in fe'}])
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase)       ->   str:




           """simple docstring"""

           _lowercase       :							Dict      		=		text_generator.model
           _lowercase       :							List[Any]      		=		text_generator.tokenizer

           _lowercase       :							Optional[int]      		=		text_generator('This is a test')
           self.assertEqual(lowerCamelCase,      [{'generated_text': ANY(lowerCamelCase)}])
           self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'))

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

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

           _lowercase       :							Tuple      		=		text_generator('This is a test',      return_full_text=lowerCamelCase)
           self.assertEqual(lowerCamelCase,      [{'generated_text': ANY(lowerCamelCase)}])
           self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'))

           _lowercase       :							int      		=		text_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)}],
               ],      )

           if text_generator.tokenizer.pad_token is not None:
               _lowercase       :							Optional[int]      		=		text_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):
               _lowercase       :							List[Any]      		=		text_generator('test',      return_full_text=lowerCamelCase,      return_text=lowerCamelCase)
           with self.assertRaises(lowerCamelCase):
               _lowercase       :							Tuple      		=		text_generator('test',      return_full_text=lowerCamelCase,      return_tensors=lowerCamelCase)
           with self.assertRaises(lowerCamelCase):
               _lowercase       :							int      		=		text_generator('test',      return_text=lowerCamelCase,      return_tensors=lowerCamelCase)

           # 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__
           ):
               _lowercase       :							Optional[int]      		=		text_generator('')
               self.assertEqual(lowerCamelCase,      [{'generated_text': ANY(lowerCamelCase)}])
           else:
               with self.assertRaises((ValueError, AssertionError)):
                   _lowercase       :							int      		=		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.
           _lowercase       :							Optional[Any]      		=		['RwkvForCausalLM', 'XGLMForCausalLM', 'GPTNeoXForCausalLM']
           if (
               tokenizer.model_max_length < 1_00_00
               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' * 5_00,      max_new_tokens=20)

               _lowercase       :							Dict      		=		text_generator('This is a test' * 5_00,      handle_long_generation='hole',      max_new_tokens=20)
               # Hole strategy cannot work
               with self.assertRaises(lowerCamelCase):
                   text_generator(
                       'This is a test' * 5_00,      handle_long_generation='hole',      max_new_tokens=tokenizer.model_max_length + 10,      )
       @require_torch
       @require_accelerate
       @require_torch_gpu
       def 			UpperCamelCase     (					self)       ->   Optional[Any]:




           """simple docstring"""

           import torch

           # Classic `model_kwargs`
           _lowercase       :							int      		=		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)
           _lowercase       :							int      		=		pipe('This is a test')
           self.assertEqual(
               lowerCamelCase,      [
                   {
                       '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.)
           _lowercase       :							Any      		=		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)
           _lowercase       :							int      		=		pipe('This is a test')
           self.assertEqual(
               lowerCamelCase,      [
                   {
                       '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
           _lowercase       :							List[str]      		=		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)
           _lowercase       :							Tuple      		=		pipe('This is a test')
           self.assertEqual(
               lowerCamelCase,      [
                   {
                       '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 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           import torch

           _lowercase       :							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 			UpperCamelCase     (					self)       ->   Union[str, Any]:




           """simple docstring"""

           import torch

           _lowercase       :							Optional[int]      		=		pipeline(model='hf-internal-testing/tiny-random-bloom',      device_map='auto',      torch_dtype=torch.floataa)
           pipe('This is a test',      do_sample=lowerCamelCase,      top_p=0.5)




       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

           _lowercase       :							Any      		=		'Hello world'
           _lowercase       :							Tuple      		=		pipeline('text-generation',      model='hf-internal-testing/tiny-random-gpt2')
           if text_generator.model.framework == "tf":
               _lowercase       :							int      		=		logging.get_logger('transformers.generation.tf_utils')
           else:
               _lowercase       :							Dict      		=		logging.get_logger('transformers.generation.utils')
           _lowercase       :							List[str]      		=		'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(lowerCamelCase) as cl:
               _lowercase       :							int      		=		text_generator(lowerCamelCase,      max_length=10,      max_new_tokens=1)
           self.assertIn(lowerCamelCase,      cl.out)

           # The user only sets one -> no warning
           with CaptureLogger(lowerCamelCase) as cl:
               _lowercase       :							str      		=		text_generator(lowerCamelCase,      max_new_tokens=1)
           self.assertNotIn(lowerCamelCase,      cl.out)

           with CaptureLogger(lowerCamelCase) as cl:
               _lowercase       :							Any      		=		text_generator(lowerCamelCase,      max_length=10)
           self.assertNotIn(lowerCamelCase,      cl.out)






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE       :      str												= {
    "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"],
}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Tuple												= ["LlamaTokenizer"]

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Optional[Any]												= ["LlamaTokenizerFast"]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      int												= [
     "LlamaForCausalLM",
     "LlamaModel",
     "LlamaPreTrainedModel",
     "LlamaForSequenceClassification",
 ]


if TYPE_CHECKING:
 from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_llama import LlamaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_llama_fast import LlamaTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel


else:
 import sys

 SCREAMING_SNAKE_CASE       :      Optional[int]												= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


