
"""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 			lowercase					( unittest.TestCase		):
			lowercase        =     MODEL_FOR_CAUSAL_LM_MAPPING
			lowercase        =     TF_MODEL_FOR_CAUSAL_LM_MAPPING






			@require_torch
			def 					UpperCAmelCase							(self  :	int			)       ->	Dict:





				"""simple docstring"""


				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=SCREAMING_SNAKE_CASE_			)
				self.assertEqual(
				    SCREAMING_SNAKE_CASE_      ,[
				        {
				            '''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(
				    SCREAMING_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												=  text_generator('''This is a test'''      ,do_sample=SCREAMING_SNAKE_CASE_      ,num_return_sequences=2      ,return_tensors=SCREAMING_SNAKE_CASE_			)
				self.assertEqual(
				    SCREAMING_SNAKE_CASE_      ,[
				        {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE_			)},
				        {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE_			)},
				    ]      ,)
				lowerCAmelCase												=  text_generator.model.config.eos_token_id
				lowerCAmelCase												=  '''<pad>'''
				lowerCAmelCase												=  text_generator(
				    ['''This is a test''', '''This is a second test''']      ,do_sample=SCREAMING_SNAKE_CASE_      ,num_return_sequences=2      ,batch_size=2      ,return_tensors=SCREAMING_SNAKE_CASE_      ,)
				self.assertEqual(
				    SCREAMING_SNAKE_CASE_      ,[
				        [
				            {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE_			)},
				            {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE_			)},
				        ],
				        [
				            {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE_			)},
				            {'''generated_token_ids''': ANY(SCREAMING_SNAKE_CASE_			)},
				        ],
				    ]      ,)






			@require_tf
			def 					UpperCAmelCase							(self  :	Optional[Any]			)       ->	List[Any]:





				"""simple docstring"""


				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=SCREAMING_SNAKE_CASE_			)
				self.assertEqual(
				    SCREAMING_SNAKE_CASE_      ,[
				        {
				            '''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=SCREAMING_SNAKE_CASE_			)
				self.assertEqual(
				    SCREAMING_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 					UpperCAmelCase							(self  :	Any      ,SCREAMING_SNAKE_CASE_  :	Optional[int]      ,SCREAMING_SNAKE_CASE_  :	str      ,SCREAMING_SNAKE_CASE_  :	str			)       ->	Union[str, Any]:





				"""simple docstring"""


				lowerCAmelCase												=  TextGenerationPipeline(model=SCREAMING_SNAKE_CASE_      ,tokenizer=SCREAMING_SNAKE_CASE_			)
				return text_generator, ["This is a test", "Another test"]






			def 					UpperCAmelCase							(self  :	Any			)       ->	Union[str, Any]:





				"""simple docstring"""


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

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






			def 					UpperCAmelCase							(self  :	Any      ,SCREAMING_SNAKE_CASE_  :	Optional[Any]      ,SCREAMING_SNAKE_CASE_  :	Optional[Any]			)       ->	Tuple:





				"""simple docstring"""


				lowerCAmelCase												=  text_generator.model
				lowerCAmelCase												=  text_generator.tokenizer

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

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

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

				lowerCAmelCase												=  text_generator('''This is a test'''      ,return_full_text=SCREAMING_SNAKE_CASE_			)
				self.assertEqual(SCREAMING_SNAKE_CASE_      ,[{'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}]			)
				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=SCREAMING_SNAKE_CASE_			)
				self.assertEqual(
				    SCREAMING_SNAKE_CASE_      ,[
				        [{'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}, {'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}],
				        [{'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}, {'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}],
				    ]      ,)

				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=SCREAMING_SNAKE_CASE_			)
					self.assertEqual(
					    SCREAMING_SNAKE_CASE_      ,[
					        [{'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}, {'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}],
					        [{'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}, {'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}],
					    ]      ,)

				with self.assertRaises(SCREAMING_SNAKE_CASE_			):
					lowerCAmelCase												=  text_generator('''test'''      ,return_full_text=SCREAMING_SNAKE_CASE_      ,return_text=SCREAMING_SNAKE_CASE_			)
				with self.assertRaises(SCREAMING_SNAKE_CASE_			):
					lowerCAmelCase												=  text_generator('''test'''      ,return_full_text=SCREAMING_SNAKE_CASE_      ,return_tensors=SCREAMING_SNAKE_CASE_			)
				with self.assertRaises(SCREAMING_SNAKE_CASE_			):
					lowerCAmelCase												=  text_generator('''test'''      ,return_text=SCREAMING_SNAKE_CASE_      ,return_tensors=SCREAMING_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												=  text_generator(''''''			)
					self.assertEqual(SCREAMING_SNAKE_CASE_      ,[{'''generated_text''': ANY(SCREAMING_SNAKE_CASE_			)}]			)
				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 < 10_000
				    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												=  text_generator('''This is a test''' * 500      ,handle_long_generation='''hole'''      ,max_new_tokens=20			)
					# Hole strategy cannot work
					with self.assertRaises(SCREAMING_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 					UpperCAmelCase							(self  :	Union[str, Any]			)       ->	List[Any]:





				"""simple docstring"""


				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(
				    SCREAMING_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												=  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(
				    SCREAMING_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												=  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(
				    SCREAMING_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 					UpperCAmelCase							(self  :	Optional[Any]			)       ->	int:





				"""simple docstring"""


				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 					UpperCAmelCase							(self  :	Any			)       ->	int:





				"""simple docstring"""


				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=SCREAMING_SNAKE_CASE_      ,top_p=0.5			)






			def 					UpperCAmelCase							(self  :	Dict			)       ->	Any:





				"""simple docstring"""


				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(SCREAMING_SNAKE_CASE_			) as cl:
					lowerCAmelCase												=  text_generator(SCREAMING_SNAKE_CASE_      ,max_length=10      ,max_new_tokens=1			)
				self.assertIn(SCREAMING_SNAKE_CASE_      ,cl.out			)

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

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




"""simple docstring"""






from itertools import count




def __magic_name__	(				_lowerCamelCase:		int = 50			)					->						int:

	'''simple docstring'''




	lowerCAmelCase												=  [1] * min_block_length

	for n in count(_lowerCamelCase			):
		fill_count_functions.append(1			)

		for block_length in range(_lowerCamelCase,					n + 1			):
			for block_start in range(n - block_length			):
				fill_count_functions[n] += fill_count_functions[
				    n - block_start - block_length - 1
				]

			fill_count_functions[n] += 1

		if fill_count_functions[n] > 1_000_000:
			break

	return n


if __name__ == "__main__":
					print(f"""{solution() = }""")


