



"""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    ):





					'''simple docstring'''



					lowercase__   :       Optional[Any]										= MODEL_FOR_CAUSAL_LM_MAPPING
					lowercase__   :       int										= TF_MODEL_FOR_CAUSAL_LM_MAPPING

					@require_torch
					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				pipeline(task='''text-generation'''				,       model='''sshleifer/tiny-ctrl'''				,       framework='''pt'''   )
									# Using `do_sample=False` to force deterministic output
									_lowerCamelCase        =				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        =				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        =				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        =				text_generator.model.config.eos_token_id
									_lowerCamelCase        =				'''<pad>'''
									_lowerCamelCase        =				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 			snake_case__      (    self   ):
									_lowerCamelCase        =				pipeline(task='''text-generation'''				,       model='''sshleifer/tiny-ctrl'''				,       framework='''tf'''   )

									# Using `do_sample=False` to force deterministic output
									_lowerCamelCase        =				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        =				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 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
									_lowerCamelCase        =				TextGenerationPipeline(model=__lowerCamelCase				,       tokenizer=__lowerCamelCase   )
									return text_generator, ["This is a test", "Another test"]

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				'''Hello I believe in'''
									_lowerCamelCase        =				pipeline('''text-generation'''				,       model='''hf-internal-testing/tiny-random-gpt2'''   )
									_lowerCamelCase        =				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        =				text_generator(__lowerCamelCase				,       stop_sequence=''' fe'''   )
									self.assertEqual(__lowerCamelCase				,       [{'''generated_text''': '''Hello I believe in fe'''}]   )

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__   ):
									_lowerCamelCase        =				text_generator.model
									_lowerCamelCase        =				text_generator.tokenizer

									_lowerCamelCase        =				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        =				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        =				pipeline(task='''text-generation'''				,       model=__lowerCamelCase				,       tokenizer=__lowerCamelCase				,       return_full_text=__lowerCamelCase   )
									_lowerCamelCase        =				text_generator('''This is a test'''   )
									self.assertEqual(__lowerCamelCase				,       [{'''generated_text''': ANY(__lowerCamelCase   )}]   )
									self.assertNotIn('''This is a test'''				,       outputs[0]['''generated_text''']   )

									_lowerCamelCase        =				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        =				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        =				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        =				text_generator('''test'''				,       return_full_text=__lowerCamelCase				,       return_text=__lowerCamelCase   )
									with self.assertRaises(__lowerCamelCase   ):
													_lowerCamelCase        =				text_generator('''test'''				,       return_full_text=__lowerCamelCase				,       return_tensors=__lowerCamelCase   )
									with self.assertRaises(__lowerCamelCase   ):
													_lowerCamelCase        =				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        =				text_generator(''''''   )
													self.assertEqual(__lowerCamelCase				,       [{'''generated_text''': ANY(__lowerCamelCase   )}]   )
									else:
													with self.assertRaises((ValueError, AssertionError)   ):
																	_lowerCamelCase        =				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        =				['''RwkvForCausalLM''', '''XGLMForCausalLM''', '''GPTNeoXForCausalLM''']
									if (
									    tokenizer.model_max_length < 1_0_0_0_0
									    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_0_0				,       max_new_tokens=2_0   )

													_lowerCamelCase        =				text_generator('''This is a test''' * 5_0_0				,       handle_long_generation='''hole'''				,       max_new_tokens=2_0   )
													# Hole strategy cannot work
													with self.assertRaises(__lowerCamelCase   ):
																	text_generator(
																	    '''This is a test''' * 5_0_0				,       handle_long_generation='''hole'''				,       max_new_tokens=tokenizer.model_max_length + 1_0				,       )

					@require_torch
					@require_accelerate
					@require_torch_gpu
					def 			snake_case__      (    self   ):
									import torch

									# Classic `model_kwargs`
									_lowerCamelCase        =				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        =				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        =				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        =				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        =				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        =				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 			snake_case__      (    self   ):
									import torch

									_lowerCamelCase        =				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 			snake_case__      (    self   ):
									import torch

									_lowerCamelCase        =				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 			snake_case__      (    self   ):
									_lowerCamelCase        =				'''Hello world'''
									_lowerCamelCase        =				pipeline('''text-generation'''				,       model='''hf-internal-testing/tiny-random-gpt2'''   )
									if text_generator.model.framework == "tf":
													_lowerCamelCase        =				logging.get_logger('''transformers.generation.tf_utils'''   )
									else:
													_lowerCamelCase        =				logging.get_logger('''transformers.generation.utils'''   )
									_lowerCamelCase        =				'''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        =				text_generator(__lowerCamelCase				,       max_length=1_0				,       max_new_tokens=1   )
									self.assertIn(__lowerCamelCase				,       cl.out   )

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

									with CaptureLogger(__lowerCamelCase   ) as cl:
													_lowerCamelCase        =				text_generator(__lowerCamelCase				,       max_length=1_0   )
									self.assertNotIn(__lowerCamelCase				,       cl.out   )





"""simple docstring"""
# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import sys
import warnings
from os.path import abspath, dirname, join


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__SCREAMING_SNAKE_CASE  :						Optional[Any]    							=      abspath(join(dirname(dirname(__file__)), '''src'''))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)



def        lowerCAmelCase_(   lowercase_     :							List[Any]							)	->       Optional[Any]:
				from diffusers.utils.testing_utils import pytest_addoption_shared

				pytest_addoption_shared(lowercase_							)




def        lowerCAmelCase_(   lowercase_     :							List[str]							)	->       List[str]:
				from diffusers.utils.testing_utils import pytest_terminal_summary_main

				_lowerCamelCase        =				terminalreporter.config.getoption('''--make-reports'''							)
				if make_reports:
								pytest_terminal_summary_main(lowercase_						,   id=lowercase_							)
