






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				:   Dict      =  MODEL_FOR_CAUSAL_LM_MAPPING
				_lowercase				:   Tuple      =  TF_MODEL_FOR_CAUSAL_LM_MAPPING



				@require_torch
				def 					__magic_name__							(      self    :    Tuple):






											'''simple docstring'''







											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=UpperCamelCase_)
											self.assertEqual(
											    UpperCamelCase_			,		[
											        {
											            """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(
											    UpperCamelCase_			,		[
											        [
											            {
											                """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=UpperCamelCase_			,		num_return_sequences=2			,		return_tensors=UpperCamelCase_)
											self.assertEqual(
											    UpperCamelCase_			,		[
											        {"""generated_token_ids""": ANY(UpperCamelCase_)},
											        {"""generated_token_ids""": ANY(UpperCamelCase_)},
											    ]			,		)
											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=UpperCamelCase_			,		num_return_sequences=2			,		batch_size=2			,		return_tensors=UpperCamelCase_			,		)
											self.assertEqual(
											    UpperCamelCase_			,		[
											        [
											            {"""generated_token_ids""": ANY(UpperCamelCase_)},
											            {"""generated_token_ids""": ANY(UpperCamelCase_)},
											        ],
											        [
											            {"""generated_token_ids""": ANY(UpperCamelCase_)},
											            {"""generated_token_ids""": ANY(UpperCamelCase_)},
											        ],
											    ]			,		)



				@require_tf
				def 					__magic_name__							(      self    :    Optional[Any]):






											'''simple docstring'''







											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=UpperCamelCase_)
											self.assertEqual(
											    UpperCamelCase_			,		[
											        {
											            """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=UpperCamelCase_)
											self.assertEqual(
											    UpperCamelCase_			,		[
											        [
											            {
											                """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 					__magic_name__							(      self    :    Union[str, Any]			,		UpperCamelCase__    :    Optional[int]			,		UpperCamelCase__    :    Optional[int]			,		UpperCamelCase__    :    Optional[int]):






											'''simple docstring'''







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



				def 					__magic_name__							(      self    :    int):






											'''simple docstring'''







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

											snake_case__	  =       text_generator(UpperCamelCase_			,		stop_sequence=""" fe""")
											self.assertEqual(UpperCamelCase_			,		[{"""generated_text""": """Hello I believe in fe"""}])



				def 					__magic_name__							(      self    :    List[Any]			,		UpperCamelCase__    :    Union[str, Any]			,		UpperCamelCase__    :    Tuple):






											'''simple docstring'''







											snake_case__	  =       text_generator.model
											snake_case__	  =       text_generator.tokenizer

											snake_case__	  =       text_generator("""This is a test""")
											self.assertEqual(UpperCamelCase_			,		[{"""generated_text""": ANY(UpperCamelCase_)}])
											self.assertTrue(outputs[0]["""generated_text"""].startswith("""This is a test"""))

											snake_case__	  =       text_generator("""This is a test"""			,		return_full_text=UpperCamelCase_)
											self.assertEqual(UpperCamelCase_			,		[{"""generated_text""": ANY(UpperCamelCase_)}])
											self.assertNotIn("""This is a test"""			,		outputs[0]["""generated_text"""])

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

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

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

											with self.assertRaises(UpperCamelCase_):
																		snake_case__	  =       text_generator("""test"""			,		return_full_text=UpperCamelCase_			,		return_text=UpperCamelCase_)
											with self.assertRaises(UpperCamelCase_):
																		snake_case__	  =       text_generator("""test"""			,		return_full_text=UpperCamelCase_			,		return_tensors=UpperCamelCase_)
											with self.assertRaises(UpperCamelCase_):
																		snake_case__	  =       text_generator("""test"""			,		return_text=UpperCamelCase_			,		return_tensors=UpperCamelCase_)

											# 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(UpperCamelCase_			,		[{"""generated_text""": ANY(UpperCamelCase_)}])
											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(UpperCamelCase_):
																									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 					__magic_name__							(      self    :    Tuple):






											'''simple docstring'''







											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(
											    UpperCamelCase_			,		[
											        {
											            """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(
											    UpperCamelCase_			,		[
											        {
											            """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(
											    UpperCamelCase_			,		[
											        {
											            """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 					__magic_name__							(      self    :    Tuple):






											'''simple docstring'''







											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 					__magic_name__							(      self    :    Tuple):






											'''simple docstring'''







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



				def 					__magic_name__							(      self    :    List[str]):






											'''simple docstring'''







											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(UpperCamelCase_) as cl:
																		snake_case__	  =       text_generator(UpperCamelCase_			,		max_length=1_0			,		max_new_tokens=1)
											self.assertIn(UpperCamelCase_			,		cl.out)

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

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








from math import factorial

a__       =     {str(digit): factorial(digit) for digit in range(1_0)}

def _UpperCAmelCase   (	a						:	int ):
							if not isinstance(a  ,					a ):
														raise TypeError("""Parameter number must be int""" )

							if number < 0:
														raise ValueError("""Parameter number must be greater than or equal to 0""" )

							# Converts number in string to iterate on its digits and adds its factorial.
							return sum(DIGIT_FACTORIAL[digit] for digit in str(a ) )

def _UpperCAmelCase   (	a						:	int = 60  ,					a						:	int = 100_0000 ):

							if not isinstance(a  ,					a ) or not isinstance(a  ,					a ):
														raise TypeError("""Parameters chain_length and number_limit must be int""" )

							if chain_length <= 0 or number_limit <= 0:
														raise ValueError(
														    """Parameters chain_length and number_limit must be greater than 0""" )

							# the counter for the chains with the exact desired length
							snake_case__	  =       0
							# the cached sizes of the previous chains
							snake_case__	  =       {}

							for start_chain_element in range(1  ,					a ):
														# The temporary set will contain the elements of the chain
														snake_case__	  =       set()
														snake_case__	  =       0

														# Stop computing the chain when you find a cached size, a repeating item or the
														# length is greater then the desired one.
														snake_case__	  =       start_chain_element
														while (
														    chain_element not in chain_sets_lengths
														    and chain_element not in chain_set
														    and chain_set_length <= chain_length
														):
																					chain_set.add(a )
																					chain_set_length += 1
																					snake_case__	  =       digit_factorial_sum(a )

														if chain_element in chain_sets_lengths:
																					chain_set_length += chain_sets_lengths[chain_element]

														snake_case__	  =       chain_set_length

														# If chain contains the exact amount of elements increase the counter
														if chain_set_length == chain_length:
																					chains_counter += 1

							return chains_counter


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(F'''{solution()}''')
