





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 						UpperCamelCase_  (  unittest.TestCase							):
					_a      :						List[Any]						    =					MODEL_FOR_CAUSAL_LM_MAPPING
					_a      :						List[Any]						    =					TF_MODEL_FOR_CAUSAL_LM_MAPPING



					@require_torch
					def   __a     (		self     :     Optional[Any]						):
							lowerCamelCase_	:     Tuple 						=      pipeline(task='text-generation'       ,      model='sshleifer/tiny-ctrl'       ,      framework='pt'						)
							# Using `do_sample=False` to force deterministic output
							lowerCamelCase_	:     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@@'
							            )
							        }
							    ]       ,      )

							lowerCamelCase_	:     str 						=      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@@'
							                )
							            }
							        ],
							    ]       ,      )

							lowerCamelCase_	:     Tuple 						=      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						)},
							    ]       ,      )
							lowerCamelCase_	:     Union[str, Any] 						=      text_generator.model.config.eos_token_id
							lowerCamelCase_	:     List[Any] 						=      '<pad>'
							lowerCamelCase_	:     Optional[int] 						=      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   __a     (		self     :     Tuple						):
							lowerCamelCase_	:     Any 						=      pipeline(task='text-generation'       ,      model='sshleifer/tiny-ctrl'       ,      framework='tf'						)

							# Using `do_sample=False` to force deterministic output
							lowerCamelCase_	:     Dict 						=      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,'
							            )
							        }
							    ]       ,      )

							lowerCamelCase_	:     int 						=      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   __a     (		self     :     Dict       ,      lowerCamelCase     :     Dict       ,      lowerCamelCase     :     int       ,      lowerCamelCase     :     Union[str, Any]						):
							lowerCamelCase_	:     Union[str, Any] 						=      TextGenerationPipeline(model=lowerCamelCase       ,      tokenizer=lowerCamelCase						)
							return text_generator, ["This is a test", "Another test"]



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

							lowerCamelCase_	:     List[str] 						=      text_generator(lowerCamelCase       ,      stop_sequence=' fe'						)
							self.assertEqual(lowerCamelCase       ,      [{'generated_text': 'Hello I believe in fe'}]						)



					def   __a     (		self     :     Tuple       ,      lowerCamelCase     :     Any       ,      lowerCamelCase     :     Any						):
							lowerCamelCase_	:     List[str] 						=      text_generator.model
							lowerCamelCase_	:     Optional[Any] 						=      text_generator.tokenizer

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

							lowerCamelCase_	:     Dict 						=      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']						)

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

							lowerCamelCase_	:     List[Any] 						=      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'						)						)

							lowerCamelCase_	:     Optional[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:
									lowerCamelCase_	:     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						):
									lowerCamelCase_	:     Any 						=      text_generator('test'       ,      return_full_text=lowerCamelCase       ,      return_text=lowerCamelCase						)
							with self.assertRaises(lowerCamelCase						):
									lowerCamelCase_	:     Any 						=      text_generator('test'       ,      return_full_text=lowerCamelCase       ,      return_tensors=lowerCamelCase						)
							with self.assertRaises(lowerCamelCase						):
									lowerCamelCase_	:     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__
							):
									lowerCamelCase_	:     Optional[int] 						=      text_generator(''						)
									self.assertEqual(lowerCamelCase       ,      [{'generated_text': ANY(lowerCamelCase						)}]						)
							else:
									with self.assertRaises((ValueError, AssertionError)						):
											lowerCamelCase_	:     Union[str, 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.
							lowerCamelCase_	:     Union[str, 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						)

									lowerCamelCase_	:     int 						=      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   __a     (		self     :     int						):
							import torch

							# Classic `model_kwargs`
							lowerCamelCase_	:     Optional[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						)
							lowerCamelCase_	:     List[Any] 						=      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.)
							lowerCamelCase_	:     int 						=      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						)
							lowerCamelCase_	:     List[str] 						=      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
							lowerCamelCase_	:     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						)
							lowerCamelCase_	:     List[str] 						=      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   __a     (		self     :     Dict						):
							import torch

							lowerCamelCase_	:     Tuple 						=      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   __a     (		self     :     str						):
							import torch

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

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







import warnings

from ...utils import logging
from .image_processing_yolos import YolosImageProcessor


_lowercase		:  int			       =logging.get_logger(__name__)






class 						UpperCamelCase_  (  snake_case__							):



					def __init__(		self     :     Tuple       ,      *lowerCamelCase     :     List[Any]       ,      **lowerCamelCase     :     Union[str, Any]						):
							warnings.warn(
							    'The class YolosFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'
							    ' use YolosImageProcessor instead.'       ,      lowerCamelCase       ,      )
							super().__init__(*lowerCamelCase       ,      **lowerCamelCase						)
