



"""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       A_			(     unittest.TestCase				):



						"""simple docstring"""
						__UpperCamelCase						=							MODEL_FOR_CAUSAL_LM_MAPPING
						__UpperCamelCase						=							TF_MODEL_FOR_CAUSAL_LM_MAPPING






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

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

												UpperCAmelCase             = text_generator('This is a test'   ,  do_sample=lowercase_   ,  num_return_sequences=2   ,  return_tensors=lowercase_					)
												self.assertEqual(
												    lowercase_   ,  [
												        {'generated_token_ids': ANY(lowercase_					)},
												        {'generated_token_ids': ANY(lowercase_					)},
												    ]   ,  )
												UpperCAmelCase             = text_generator.model.config.eos_token_id
												UpperCAmelCase             = '<pad>'
												UpperCAmelCase             = text_generator(
												    ['This is a test', 'This is a second test']   ,  do_sample=lowercase_   ,  num_return_sequences=2   ,  batch_size=2   ,  return_tensors=lowercase_   ,  )
												self.assertEqual(
												    lowercase_   ,  [
												        [
												            {'generated_token_ids': ANY(lowercase_					)},
												            {'generated_token_ids': ANY(lowercase_					)},
												        ],
												        [
												            {'generated_token_ids': ANY(lowercase_					)},
												            {'generated_token_ids': ANY(lowercase_					)},
												        ],
												    ]   ,  )






						@require_tf
						def 	UpperCAmelCase__     (					self :Union[str, Any]					)				->			Union[str, Any]:
												UpperCAmelCase             = pipeline(task='text-generation'   ,  model='sshleifer/tiny-ctrl'   ,  framework='tf'					)

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

												UpperCAmelCase             = text_generator(['This is a test', 'This is a second test']   ,  do_sample=lowercase_					)
												self.assertEqual(
												    lowercase_   ,  [
												        [
												            {
												                '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 :List[Any]   ,  lowercase_ :List[Any]   ,  lowercase_ :List[Any]   ,  lowercase_ :Dict					)				->			Union[str, Any]:
												UpperCAmelCase             = TextGenerationPipeline(model=lowercase_   ,  tokenizer=lowercase_					)
												return text_generator, ["This is a test", "Another test"]






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

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






						def 	UpperCAmelCase__     (					self :Union[str, Any]   ,  lowercase_ :Optional[Any]   ,  lowercase_ :List[str]					)				->			Union[str, Any]:
												UpperCAmelCase             = text_generator.model
												UpperCAmelCase             = text_generator.tokenizer

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

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

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

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

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

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

												with self.assertRaises(lowercase_					):
																		UpperCAmelCase             = text_generator('test'   ,  return_full_text=lowercase_   ,  return_text=lowercase_					)
												with self.assertRaises(lowercase_					):
																		UpperCAmelCase             = text_generator('test'   ,  return_full_text=lowercase_   ,  return_tensors=lowercase_					)
												with self.assertRaises(lowercase_					):
																		UpperCAmelCase             = text_generator('test'   ,  return_text=lowercase_   ,  return_tensors=lowercase_					)

												# 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__
												):
																		UpperCAmelCase             = text_generator(''					)
																		self.assertEqual(lowercase_   ,  [{'generated_text': ANY(lowercase_					)}]					)
												else:
																		with self.assertRaises((ValueError, AssertionError)					):
																								UpperCAmelCase             = 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.
												UpperCAmelCase             = ['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					)

																		UpperCAmelCase             = text_generator('This is a test' * 5_00   ,  handle_long_generation='hole'   ,  max_new_tokens=20					)
																		# Hole strategy cannot work
																		with self.assertRaises(lowercase_					):
																								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]					)				->			Any:
												import torch

												# Classic `model_kwargs`
												UpperCAmelCase             = 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					)
												UpperCAmelCase             = pipe('This is a test'					)
												self.assertEqual(
												    lowercase_   ,  [
												        {
												            '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.)
												UpperCAmelCase             = 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					)
												UpperCAmelCase             = pipe('This is a test'					)
												self.assertEqual(
												    lowercase_   ,  [
												        {
												            '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
												UpperCAmelCase             = 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					)
												UpperCAmelCase             = pipe('This is a test'					)
												self.assertEqual(
												    lowercase_   ,  [
												        {
												            '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 :Tuple					)				->			Optional[int]:
												import torch

												UpperCAmelCase             = 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 :str					)				->			List[Any]:
												import torch

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






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

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

												with CaptureLogger(lowercase_					) as cl:
																		UpperCAmelCase             = text_generator(lowercase_   ,  max_length=10					)
												self.assertNotIn(lowercase_   ,  cl.out					)












'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase					:     int												={
    '''configuration_bigbird_pegasus''': [
        '''BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''BigBirdPegasusConfig''',
        '''BigBirdPegasusOnnxConfig''',
    ],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase					:     Any												=[
     '''BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''BigBirdPegasusForCausalLM''',
     '''BigBirdPegasusForConditionalGeneration''',
     '''BigBirdPegasusForQuestionAnswering''',
     '''BigBirdPegasusForSequenceClassification''',
     '''BigBirdPegasusModel''',
     '''BigBirdPegasusPreTrainedModel''',
 ]


if TYPE_CHECKING:
 from .configuration_bigbird_pegasus import (
     BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
     BigBirdPegasusConfig,
     BigBirdPegasusOnnxConfig,
 )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_bigbird_pegasus import (
      BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
      BigBirdPegasusForCausalLM,
      BigBirdPegasusForConditionalGeneration,
      BigBirdPegasusForQuestionAnswering,
      BigBirdPegasusForSequenceClassification,
      BigBirdPegasusModel,
      BigBirdPegasusPreTrainedModel,
  )


else:
 import sys

 lowerCAmelCase					:     Dict												=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


