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				):
							_UpperCAmelCase						    =     MODEL_FOR_CAUSAL_LM_MAPPING
							_UpperCAmelCase						    =     TF_MODEL_FOR_CAUSAL_LM_MAPPING







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

										lowerCamelCase						: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@@'''
										                )
										            }
										        ],
										    ]	,					)

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

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

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







							def 				snake_case  (				self     :    Tuple		):
										lowerCamelCase						:Dict						  =     '''Hello I believe in'''
										lowerCamelCase						:Union[str, Any]						  =     pipeline('''text-generation'''	,					model='''hf-internal-testing/tiny-random-gpt2'''		)
										lowerCamelCase						: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'''}]	,					)

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







							def 				snake_case  (				self     :    Union[str, Any]	,					__snake_case     :    Union[str, Any]	,					__snake_case     :    Any		):
										lowerCamelCase						:Any						  =     text_generator.model
										lowerCamelCase						:int						  =     text_generator.tokenizer

										lowerCamelCase						:Optional[Any]						  =     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'''		)		)

										lowerCamelCase						:Tuple						  =     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''']		)

										lowerCamelCase						:Dict						  =     pipeline(task='''text-generation'''	,					model=__snake_case	,					tokenizer=__snake_case	,					return_full_text=__snake_case		)
										lowerCamelCase						:List[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''']		)

										lowerCamelCase						:int						  =     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'''		)		)

										lowerCamelCase						:Dict						  =     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:
													lowerCamelCase						:Optional[Any]						  =     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		):
													lowerCamelCase						:Tuple						  =     text_generator('''test'''	,					return_full_text=__snake_case	,					return_text=__snake_case		)
										with self.assertRaises(__snake_case		):
													lowerCamelCase						:Tuple						  =     text_generator('''test'''	,					return_full_text=__snake_case	,					return_tensors=__snake_case		)
										with self.assertRaises(__snake_case		):
													lowerCamelCase						:Tuple						  =     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__
										):
													lowerCamelCase						:Any						  =     text_generator(''''''		)
													self.assertEqual(__snake_case	,					[{'''generated_text''': ANY(__snake_case		)}]		)
										else:
													with self.assertRaises((ValueError, AssertionError)		):
																lowerCamelCase						: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.
										lowerCamelCase						:Dict						  =     ['''RwkvForCausalLM''', '''XGLMForCausalLM''', '''GPTNeoXForCausalLM''']
										if (
										    tokenizer.model_max_length < 10000
										    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''' * 500	,					max_new_tokens=20		)

													lowerCamelCase						:Union[str, Any]						  =     text_generator('''This is a test''' * 500	,					handle_long_generation='''hole'''	,					max_new_tokens=20		)
													# Hole strategy cannot work
													with self.assertRaises(__snake_case		):
																text_generator(
																    '''This is a test''' * 500	,					handle_long_generation='''hole'''	,					max_new_tokens=tokenizer.model_max_length + 10	,					)







							@require_torch
							@require_accelerate
							@require_torch_gpu
							def 				snake_case  (				self     :    Union[str, Any]		):
										import torch

										# Classic `model_kwargs`
										lowerCamelCase						: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						:Union[str, 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'''
										            )
										        }
										    ]	,					)

										# Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
										lowerCamelCase						:Optional[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		)
										lowerCamelCase						:Optional[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'''
										            )
										        }
										    ]	,					)

										# torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
										lowerCamelCase						: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		)
										lowerCamelCase						: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 				snake_case  (				self     :    Optional[int]		):
										import torch

										lowerCamelCase						:int						  =     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     :    Dict		):
										import torch

										lowerCamelCase						:Dict						  =     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 				snake_case  (				self     :    Dict		):
										lowerCamelCase						:int						  =     '''Hello world'''
										lowerCamelCase						:List[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						:List[Any]						  =     '''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:
													lowerCamelCase						: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:
													lowerCamelCase						:List[Any]						  =     text_generator(__snake_case	,					max_new_tokens=1		)
										self.assertNotIn(__snake_case	,					cl.out		)

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




import os
from math import logaa





def  _lowerCamelCase					(   a_				: str = "base_exp.txt"):
			lowerCamelCase						:float						  =     0
			lowerCamelCase						:Optional[int]						  =     0
			for i, line in enumerate(open(os.path.join(os.path.dirname(a_)						,			a_))):
						lowerCamelCase  ,    lowerCamelCase						:Optional[int]						  =     list(map(a_						,			line.split(''',''')))
						if x * logaa(a_) > largest:
									lowerCamelCase						:List[Any]						  =     x * logaa(a_)
									lowerCamelCase						:Any						  =     i + 1
			return result


if __name__ == "__main__":
			print(solution())



