





"""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 			__UpperCamelCase							(		unittest.TestCase		):
							lowerCamelCase  :   List[str]    =MODEL_FOR_CAUSAL_LM_MAPPING
							lowerCamelCase  :   Tuple    =TF_MODEL_FOR_CAUSAL_LM_MAPPING






							@require_torch
							def        __a  (  self )      ->					Optional[int]:
								a :						Tuple      =							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=lowerCAmelCase__ )
								self.assertEqual(
								    lowerCAmelCase__ ,   [
								        {
								            "generated_text": (
								                "This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
								                " oscope. FiliFili@@"
								            )
								        }
								    ] ,   )

								a :						List[str]      =							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@@"
								                )
								            }
								        ],
								    ] ,   )

								a :						List[str]      =							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__ )},
								    ] ,   )
								a :						Optional[int]      =							text_generator.model.config.eos_token_id
								a :						Tuple      =							"<pad>"
								a :						Dict      =							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        __a  (  self )      ->					Optional[Any]:
								a :						int      =							pipeline(task="text-generation" ,   model="sshleifer/tiny-ctrl" ,   framework="tf" )

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

								a :						Union[str, Any]      =							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        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Optional[Any]:
								a :						Union[str, Any]      =							TextGenerationPipeline(model=lowerCAmelCase__ ,   tokenizer=lowerCAmelCase__ )
								return text_generator, ["This is a test", "Another test"]






							def        __a  (  self )      ->					List[Any]:
								a :						int      =							"Hello I believe in"
								a :						List[Any]      =							pipeline("text-generation" ,   model="hf-internal-testing/tiny-random-gpt2" )
								a :						str      =							text_generator(lowerCAmelCase__ )
								self.assertEqual(
								    lowerCAmelCase__ ,   [{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}] ,   )

								a :						Union[str, Any]      =							text_generator(lowerCAmelCase__ ,   stop_sequence=" fe" )
								self.assertEqual(lowerCAmelCase__ ,   [{"generated_text": "Hello I believe in fe"}] )






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Optional[int]:
								a :						int      =							text_generator.model
								a :						Tuple      =							text_generator.tokenizer

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

								a :						int      =							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"] )

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

								a :						Optional[int]      =							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" ) )

								a :						List[str]      =							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:
									a :						int      =							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__ ):
									a :						int      =							text_generator("test" ,   return_full_text=lowerCAmelCase__ ,   return_text=lowerCAmelCase__ )
								with self.assertRaises(lowerCAmelCase__ ):
									a :						List[str]      =							text_generator("test" ,   return_full_text=lowerCAmelCase__ ,   return_tensors=lowerCAmelCase__ )
								with self.assertRaises(lowerCAmelCase__ ):
									a :						Optional[Any]      =							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__
								):
									a :						List[Any]      =							text_generator("" )
									self.assertEqual(lowerCAmelCase__ ,   [{"generated_text": ANY(lowerCAmelCase__ )}] )
								else:
									with self.assertRaises((ValueError, AssertionError) ):
										a :						Tuple      =							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 :						Tuple      =							["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 :						Optional[int]      =							text_generator("This is a test" * 500 ,   handle_long_generation="hole" ,   max_new_tokens=20 )
									# Hole strategy cannot work
									with self.assertRaises(lowerCAmelCase__ ):
										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        __a  (  self )      ->					List[Any]:
								import torch

								# Classic `model_kwargs`
								a :						List[str]      =							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 :						Any      =							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.)
								a :						Dict      =							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 :						int      =							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
								a :						Tuple      =							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 :						List[Any]      =							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        __a  (  self )      ->					List[str]:
								import torch

								a :						List[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        __a  (  self )      ->					Dict:
								import torch

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

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

								with CaptureLogger(lowerCAmelCase__ ) as cl:
									a :						Optional[Any]      =							text_generator(lowerCAmelCase__ ,   max_length=10 )
								self.assertNotIn(lowerCAmelCase__ ,   cl.out )









"""simple docstring"""




def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list[int]   )					->float:






	'''simple docstring'''






	if not nums:  # Makes sure that the list is not empty
		raise ValueError("List is empty"   )

	a :						Dict      =							sum(_lowercase   ) / len(_lowercase   )  # Calculate the average
	return sum(abs(x - average   ) for x in nums   ) / len(_lowercase   )


if __name__ == "__main__":
		import doctest

		doctest.testmod()


