





'''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 			lowerCamelCase					(						unittest.TestCase  ):
					_SCREAMING_SNAKE_CASE							   =    MODEL_FOR_CAUSAL_LM_MAPPING
					_SCREAMING_SNAKE_CASE							   =    TF_MODEL_FOR_CAUSAL_LM_MAPPING


					@require_torch
					def    SCREAMING_SNAKE_CASE_		(					self	:  Dict       ):





											'''simple docstring'''





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

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

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


					@require_tf
					def    SCREAMING_SNAKE_CASE_		(					self	:  List[Any]       ):





											'''simple docstring'''





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

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

											_snake_case:   Dict  					=		text_generator(['This is a test', 'This is a second test']       ,     do_sample=__snake_case       )
											self.assertEqual(
											    __snake_case       ,     [
											        [
											            {
											                '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	:  Dict       ,     __snake_case	:  Any       ,     __snake_case	:  str       ,     __snake_case	:  List[Any]       ):





											'''simple docstring'''





											_snake_case:   List[str]  					=		TextGenerationPipeline(model=__snake_case       ,     tokenizer=__snake_case       )
											return text_generator, ["This is a test", "Another test"]


					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[Any]       ):





											'''simple docstring'''





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

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


					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[Any]       ,     __snake_case	:  Dict       ,     __snake_case	:  List[str]       ):





											'''simple docstring'''





											_snake_case:   Tuple  					=		text_generator.model
											_snake_case:   Optional[int]  					=		text_generator.tokenizer

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

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

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

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

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

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

											with self.assertRaises(__snake_case       ):
																	_snake_case:   Dict  					=		text_generator('test'       ,     return_full_text=__snake_case       ,     return_text=__snake_case       )
											with self.assertRaises(__snake_case       ):
																	_snake_case:   List[str]  					=		text_generator('test'       ,     return_full_text=__snake_case       ,     return_tensors=__snake_case       )
											with self.assertRaises(__snake_case       ):
																	_snake_case:   List[Any]  					=		text_generator('test'       ,     return_text=__snake_case       ,     return_tensors=__snake_case       )

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

																	_snake_case:   List[Any]  					=		text_generator('This is a test' * 5_00       ,     handle_long_generation='hole'       ,     max_new_tokens=20       )
																	# Hole strategy cannot work
																	with self.assertRaises(__snake_case       ):
																							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    SCREAMING_SNAKE_CASE_		(					self	:  Dict       ):





											'''simple docstring'''





											import torch

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





											'''simple docstring'''





											import torch

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





											'''simple docstring'''





											import torch

											_snake_case:   Union[str, Any]  					=		pipeline(model='hf-internal-testing/tiny-random-bloom'       ,     device_map='auto'       ,     torch_dtype=torch.floataa       )
											pipe('This is a test'       ,     do_sample=__snake_case       ,     top_p=0.5       )




					def    SCREAMING_SNAKE_CASE_		(					self	:  Tuple       ):





											'''simple docstring'''





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

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

											with CaptureLogger(__snake_case       ) as cl:
																	_snake_case:   Optional[Any]  					=		text_generator(__snake_case       ,     max_length=10       )
											self.assertNotIn(__snake_case       ,     cl.out       )












'''simple docstring'''






A   : List[str]             =			'\n# Transformers 설치 방법\n! pip install transformers datasets\n# 마지막 릴리스 대신 소스에서 설치하려면, 위 명령을 주석으로 바꾸고 아래 명령을 해제하세요.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'

A   : List[str]             =			[{'type': 'code', 'content': INSTALL_CONTENT}]
A   : Dict             =			{
    '{processor_class}': 'FakeProcessorClass',
    '{model_class}': 'FakeModelClass',
    '{object_class}': 'FakeObjectClass',
}





