



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    SCREAMING_SNAKE_CASE			(							unittest.TestCase					):
							__lowerCamelCase	:	int    =MODEL_FOR_CAUSAL_LM_MAPPING
							__lowerCamelCase	:	Union[str, Any]    =TF_MODEL_FOR_CAUSAL_LM_MAPPING





							@require_torch
							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											__a       =		pipeline(task="""text-generation"""      ,				model="""sshleifer/tiny-ctrl"""      ,				framework="""pt"""	)
											# Using `do_sample=False` to force deterministic output
											__a       =		text_generator("""This is a test"""      ,				do_sample=__lowercase	)
											self.assertEqual(
											    __lowercase      ,				[
											        {
											            """generated_text""": (
											                """This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."""
											                """ oscope. FiliFili@@"""
											            )
											        }
											    ]      ,				)

											__a       =		text_generator(["""This is a test""", """This is a second test"""]	)
											self.assertEqual(
											    __lowercase      ,				[
											        [
											            {
											                """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@@"""
											                )
											            }
											        ],
											    ]      ,				)

											__a       =		text_generator("""This is a test"""      ,				do_sample=__lowercase      ,				num_return_sequences=2      ,				return_tensors=__lowercase	)
											self.assertEqual(
											    __lowercase      ,				[
											        {"""generated_token_ids""": ANY(__lowercase	)},
											        {"""generated_token_ids""": ANY(__lowercase	)},
											    ]      ,				)
											__a       =		text_generator.model.config.eos_token_id
											__a       =		"""<pad>"""
											__a       =		text_generator(
											    ["""This is a test""", """This is a second test"""]      ,				do_sample=__lowercase      ,				num_return_sequences=2      ,				batch_size=2      ,				return_tensors=__lowercase      ,				)
											self.assertEqual(
											    __lowercase      ,				[
											        [
											            {"""generated_token_ids""": ANY(__lowercase	)},
											            {"""generated_token_ids""": ANY(__lowercase	)},
											        ],
											        [
											            {"""generated_token_ids""": ANY(__lowercase	)},
											            {"""generated_token_ids""": ANY(__lowercase	)},
											        ],
											    ]      ,				)





							@require_tf
							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a       =		pipeline(task="""text-generation"""      ,				model="""sshleifer/tiny-ctrl"""      ,				framework="""tf"""	)

											# Using `do_sample=False` to force deterministic output
											__a       =		text_generator("""This is a test"""      ,				do_sample=__lowercase	)
											self.assertEqual(
											    __lowercase      ,				[
											        {
											            """generated_text""": (
											                """This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"""
											                """ please,"""
											            )
											        }
											    ]      ,				)

											__a       =		text_generator(["""This is a test""", """This is a second test"""]      ,				do_sample=__lowercase	)
											self.assertEqual(
											    __lowercase      ,				[
											        [
											            {
											                """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      ,				__lowercase		:		Optional[int]      ,				__lowercase		:		Dict      ,				__lowercase		:		Dict	):

											'''simple docstring'''
											__a       =		TextGenerationPipeline(model=__lowercase      ,				tokenizer=__lowercase	)
											return text_generator, ["This is a test", "Another test"]





							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

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

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





							def 						UpperCamelCase_					(   self		:		List[str]      ,				__lowercase		:		Optional[int]      ,				__lowercase		:		List[Any]	):

											'''simple docstring'''
											__a       =		text_generator.model
											__a       =		text_generator.tokenizer

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

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

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

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

											__a       =		text_generator(["""This is great !""", """Something else"""]      ,				num_return_sequences=2      ,				do_sample=__lowercase	)
											self.assertEqual(
											    __lowercase      ,				[
											        [{"""generated_text""": ANY(__lowercase	)}, {"""generated_text""": ANY(__lowercase	)}],
											        [{"""generated_text""": ANY(__lowercase	)}, {"""generated_text""": ANY(__lowercase	)}],
											    ]      ,				)

											if text_generator.tokenizer.pad_token is not None:
															__a       =		text_generator(
															    ["""This is great !""", """Something else"""]      ,				num_return_sequences=2      ,				batch_size=2      ,				do_sample=__lowercase	)
															self.assertEqual(
															    __lowercase      ,				[
															        [{"""generated_text""": ANY(__lowercase	)}, {"""generated_text""": ANY(__lowercase	)}],
															        [{"""generated_text""": ANY(__lowercase	)}, {"""generated_text""": ANY(__lowercase	)}],
															    ]      ,				)

											with self.assertRaises(__lowercase	):
															__a       =		text_generator("""test"""      ,				return_full_text=__lowercase      ,				return_text=__lowercase	)
											with self.assertRaises(__lowercase	):
															__a       =		text_generator("""test"""      ,				return_full_text=__lowercase      ,				return_tensors=__lowercase	)
											with self.assertRaises(__lowercase	):
															__a       =		text_generator("""test"""      ,				return_text=__lowercase      ,				return_tensors=__lowercase	)

											# 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__
											):
															__a       =		text_generator(""""""	)
															self.assertEqual(__lowercase      ,				[{"""generated_text""": ANY(__lowercase	)}]	)
											else:
															with self.assertRaises((ValueError, AssertionError)	):
																			__a       =		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.
											__a       =		["""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	)

															__a       =		text_generator("""This is a test""" * 500      ,				handle_long_generation="""hole"""      ,				max_new_tokens=20	)
															# Hole strategy cannot work
															with self.assertRaises(__lowercase	):
																			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		:		Any	):

											'''simple docstring'''
											import torch

											# Classic `model_kwargs`
											__a       =		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	)
											__a       =		pipe("""This is a test"""	)
											self.assertEqual(
											    __lowercase      ,				[
											        {
											            """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.)
											__a       =		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	)
											__a       =		pipe("""This is a test"""	)
											self.assertEqual(
											    __lowercase      ,				[
											        {
											            """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
											__a       =		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	)
											__a       =		pipe("""This is a test"""	)
											self.assertEqual(
											    __lowercase      ,				[
											        {
											            """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		:		Dict	):

											'''simple docstring'''
											import torch

											__a       =		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		:		List[Any]	):

											'''simple docstring'''
											import torch

											__a       =		pipeline(model="""hf-internal-testing/tiny-random-bloom"""      ,				device_map="""auto"""      ,				torch_dtype=torch.floataa	)
											pipe("""This is a test"""      ,				do_sample=__lowercase      ,				top_p=0.5	)







							def 						UpperCamelCase_					(   self		:		Any	):

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

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

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





from math import sqrt

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			int    ):
				"""simple docstring"""







				if 1 < number < 4:
								# 2 and 3 are primes
								return True
				elif number < 2 or number % 2 == 0 or number % 3 == 0:
								# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
								return False

				# All primes number are in format of 6k +/- 1
				for i in range(5				,     int(sqrt(_SCREAMING_SNAKE_CASE    ) + 1    )				,     6    ):
								if number % i == 0 or number % (i + 2) == 0:
												return False
				return True

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			int = 1_0001    ):
				"""simple docstring"""







				__a       =		0
				__a       =		1
				while count != nth and number < 3:
								number += 1
								if is_prime(_SCREAMING_SNAKE_CASE    ):
												count += 1
				while count != nth:
								number += 2
								if is_prime(_SCREAMING_SNAKE_CASE    ):
												count += 1
				return number


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