




'''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 						a_				(			unittest.TestCase						):
	lowercase_       :     int			  =      MODEL_FOR_CAUSAL_LM_MAPPING
	lowercase_       :     Any			  =      TF_MODEL_FOR_CAUSAL_LM_MAPPING




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

							__snake_case						 =   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@@'
							                )
							            }
							        ],
							    ]       ,		)

							__snake_case						 =   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      )},
							    ]       ,		)
							__snake_case						 =   text_generator.model.config.eos_token_id
							__snake_case						 =   '<pad>'
							__snake_case						 =   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   lowercase__   (       self     :  Dict      ):
							__snake_case						 =   pipeline(task='text-generation'       ,		model='sshleifer/tiny-ctrl'       ,		framework='tf'      )

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

							__snake_case						 =   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   lowercase__   (       self     :  str       ,		__lowerCAmelCase     :  List[str]       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  List[str]      ):
							__snake_case						 =   TextGenerationPipeline(model=__lowerCAmelCase       ,		tokenizer=__lowerCAmelCase      )
							return text_generator, ["This is a test", "Another test"]




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

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




	def   lowercase__   (       self     :  Union[str, Any]       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  List[str]      ):
							__snake_case						 =   text_generator.model
							__snake_case						 =   text_generator.tokenizer

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

							__snake_case						 =   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']      )

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

							__snake_case						 =   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'      )      )

							__snake_case						 =   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:
													__snake_case						 =   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      ):
													__snake_case						 =   text_generator('test'       ,		return_full_text=__lowerCAmelCase       ,		return_text=__lowerCAmelCase      )
							with self.assertRaises(__lowerCAmelCase      ):
													__snake_case						 =   text_generator('test'       ,		return_full_text=__lowerCAmelCase       ,		return_tensors=__lowerCAmelCase      )
							with self.assertRaises(__lowerCAmelCase      ):
													__snake_case						 =   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__
							):
													__snake_case						 =   text_generator(''      )
													self.assertEqual(__lowerCAmelCase       ,		[{'generated_text': ANY(__lowerCAmelCase      )}]      )
							else:
													with self.assertRaises((ValueError, AssertionError)      ):
																			__snake_case						 =   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						 =   ['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      )

													__snake_case						 =   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   lowercase__   (       self     :  Dict      ):
							import torch

							# Classic `model_kwargs`
							__snake_case						 =   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						 =   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.)
							__snake_case						 =   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						 =   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
							__snake_case						 =   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						 =   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   lowercase__   (       self     :  int      ):
							import torch

							__snake_case						 =   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   lowercase__   (       self     :  Union[str, Any]      ):
							import torch

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

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









'''simple docstring'''



import sys

__UpperCamelCase   :							List[str]         =   (
    """73167176531330624919225119674426574742355349194934"""
    """96983520312774506326239578318016984801869478851843"""
    """85861560789112949495459501737958331952853208805511"""
    """12540698747158523863050715693290963295227443043557"""
    """66896648950445244523161731856403098711121722383113"""
    """62229893423380308135336276614282806444486645238749"""
    """30358907296290491560440772390713810515859307960866"""
    """70172427121883998797908792274921901699720888093776"""
    """65727333001053367881220235421809751254540594752243"""
    """52584907711670556013604839586446706324415722155397"""
    """53697817977846174064955149290862569321978468622482"""
    """83972241375657056057490261407972968652414535100474"""
    """82166370484403199890008895243450658541227588666881"""
    """16427171479924442928230863465674813919123162824586"""
    """17866458359124566529476545682848912883142607690042"""
    """24219022671055626321111109370544217506941658960408"""
    """07198403850962455444362981230987879927244284909188"""
    """84580156166097919133875499200524063689912560717606"""
    """05886116467109405077541002256983155200055935729725"""
    """71636269561882670428252483600823257530420752963450"""
)



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str = N     )	->      int:

   """simple docstring"""
   __a					  =     -sys.maxsize - 1
   for i in range(len(SCREAMING_SNAKE_CASE__     ) - 12     ):
      __a					  =     1
      for j in range(13     ):
         product *= int(n[i + j]     )
      if product > largest_product:
         __a					  =     product
   return largest_product


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