





'''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 			SCREAMING_SNAKE_CASE   (unittest.TestCase							):
					lowerCAmelCase		      =	MODEL_FOR_CAUSAL_LM_MAPPING
					lowerCAmelCase		      =	TF_MODEL_FOR_CAUSAL_LM_MAPPING


					@require_torch
					def 							SCREAMING_SNAKE_CASE  (						self):

										'''simple docstring'''






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

										__A						:			int								=	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@@'
										                )
										            }
										        ],
										    ]						,     )

										__A						:			Any								=	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)},
										    ]						,     )
										__A						:			List[str]								=	text_generator.model.config.eos_token_id
										__A						:			Optional[int]								=	'<pad>'
										__A						:			Tuple								=	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 							SCREAMING_SNAKE_CASE  (						self):

										'''simple docstring'''






										__A						:			Any								=	pipeline(task='text-generation'						,     model='sshleifer/tiny-ctrl'						,     framework='tf')

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

										__A						:			str								=	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 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase						,     _UpperCAmelCase						,     _UpperCAmelCase):

										'''simple docstring'''






										__A						:			Dict								=	TextGenerationPipeline(model=_UpperCAmelCase						,     tokenizer=_UpperCAmelCase)
										return text_generator, ["This is a test", "Another test"]


					def 							SCREAMING_SNAKE_CASE  (						self):

										'''simple docstring'''






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

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


					def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase						,     _UpperCAmelCase):

										'''simple docstring'''






										__A						:			Optional[int]								=	text_generator.model
										__A						:			Union[str, Any]								=	text_generator.tokenizer

										__A						:			Union[str, Any]								=	text_generator('This is a test')
										self.assertEqual(_UpperCAmelCase						,     [{'generated_text': ANY(_UpperCAmelCase)}])
										self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'))

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

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

										__A						:			List[str]								=	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'))

										__A						:			Optional[Any]								=	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:
															__A						:			int								=	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):
															__A						:			Dict								=	text_generator('test'						,     return_full_text=_UpperCAmelCase						,     return_text=_UpperCAmelCase)
										with self.assertRaises(_UpperCAmelCase):
															__A						:			int								=	text_generator('test'						,     return_full_text=_UpperCAmelCase						,     return_tensors=_UpperCAmelCase)
										with self.assertRaises(_UpperCAmelCase):
															__A						:			Optional[int]								=	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__
										):
															__A						:			Dict								=	text_generator('')
															self.assertEqual(_UpperCAmelCase						,     [{'generated_text': ANY(_UpperCAmelCase)}])
										else:
															with self.assertRaises((ValueError, AssertionError)):
																				__A						:			Optional[Any]								=	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						:			Optional[Any]								=	['RwkvForCausalLM', 'XGLMForCausalLM', 'GPTNeoXForCausalLM']
										if (
										    tokenizer.model_max_length < 1_0000
										    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						:			Tuple								=	text_generator('This is a test' * 500						,     handle_long_generation='hole'						,     max_new_tokens=20)
															# Hole strategy cannot work
															with self.assertRaises(_UpperCAmelCase):
																				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 							SCREAMING_SNAKE_CASE  (						self):

										'''simple docstring'''






										import torch

										# Classic `model_kwargs`
										__A						:			Union[str, Any]								=	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						:			Union[str, Any]								=	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.)
										__A						:			Tuple								=	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						:			Optional[int]								=	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
										__A						:			Optional[Any]								=	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						:			Union[str, Any]								=	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 							SCREAMING_SNAKE_CASE  (						self):

										'''simple docstring'''






										import torch

										__A						:			Optional[Any]								=	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 							SCREAMING_SNAKE_CASE  (						self):

										'''simple docstring'''






										import torch

										__A						:			List[Any]								=	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 							SCREAMING_SNAKE_CASE  (						self):

										'''simple docstring'''






										__A						:			List[Any]								=	'Hello world'
										__A						:			Any								=	pipeline('text-generation'						,     model='hf-internal-testing/tiny-random-gpt2')
										if text_generator.model.framework == "tf":
															__A						:			Union[str, Any]								=	logging.get_logger('transformers.generation.tf_utils')
										else:
															__A						:			Dict								=	logging.get_logger('transformers.generation.utils')
										__A						:			Optional[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(_UpperCAmelCase) as cl:
															__A						:			List[Any]								=	text_generator(_UpperCAmelCase						,     max_length=10						,     max_new_tokens=1)
										self.assertIn(_UpperCAmelCase						,     cl.out)

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

										with CaptureLogger(_UpperCAmelCase) as cl:
															__A						:			str								=	text_generator(_UpperCAmelCase						,     max_length=10)
										self.assertNotIn(_UpperCAmelCase						,     cl.out)






'''simple docstring'''




import math






def 	_lowerCAmelCase      (  __snake_case  :			int      )					->					bool:

     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(math.sqrt(__snake_case      ) + 1      )			,							6      ):
          if number % i == 0 or number % (i + 2) == 0:
               return False
     return True






def 	_lowerCAmelCase      (  __snake_case  :			float = 0.1      )					->					int:
     __A						:			Dict								=	3
     __A						:			int								=	3

     while primes / (2 * j - 1) >= ratio:
          for i in range(j * j + j + 1			,							(j + 2) * (j + 2)			,							j + 1      ):
               primes += is_prime(__snake_case      )
          j += 2
     return j


if __name__ == "__main__":
  import doctest

  doctest.testmod()