






"""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							):




						"""simple docstring"""




						__lowerCamelCase    	= MODEL_FOR_CAUSAL_LM_MAPPING
						__lowerCamelCase    	= TF_MODEL_FOR_CAUSAL_LM_MAPPING




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

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

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




						@require_tf
						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Dict=	pipeline(task="text-generation"	,  model="sshleifer/tiny-ctrl"	,  framework="tf"      )

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

												lowercase__    :				int=	text_generator(["This is a test", "This is a second test"]	,  do_sample=snake_case__      )
												self.assertEqual(
												    snake_case__	,  [
												        [
												            {
												                "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	,  snake_case__	,  snake_case__	,  snake_case__      ):
												'''simple docstring'''
												lowercase__    :				Dict=	TextGenerationPipeline(model=snake_case__	,  tokenizer=snake_case__      )
												return text_generator, ["This is a test", "Another test"]




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Optional[int]=	"Hello I believe in"
												lowercase__    :				Union[str, Any]=	pipeline("text-generation"	,  model="hf-internal-testing/tiny-random-gpt2"      )
												lowercase__    :				Optional[Any]=	text_generator(snake_case__      )
												self.assertEqual(
												    snake_case__	,  [{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}]	,  )

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




						def 		UpperCAmelCase_	(       self	,  snake_case__	,  snake_case__      ):
												'''simple docstring'''
												lowercase__    :				List[str]=	text_generator.model
												lowercase__    :				List[Any]=	text_generator.tokenizer

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

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

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

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

												lowercase__    :				Union[str, Any]=	text_generator(["This is great !", "Something else"]	,  num_return_sequences=2	,  do_sample=snake_case__      )
												self.assertEqual(
												    snake_case__	,  [
												        [{"generated_text": ANY(snake_case__      )}, {"generated_text": ANY(snake_case__      )}],
												        [{"generated_text": ANY(snake_case__      )}, {"generated_text": ANY(snake_case__      )}],
												    ]	,  )

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

												with self.assertRaises(snake_case__      ):
																		lowercase__    :				Optional[int]=	text_generator("test"	,  return_full_text=snake_case__	,  return_text=snake_case__      )
												with self.assertRaises(snake_case__      ):
																		lowercase__    :				int=	text_generator("test"	,  return_full_text=snake_case__	,  return_tensors=snake_case__      )
												with self.assertRaises(snake_case__      ):
																		lowercase__    :				Any=	text_generator("test"	,  return_text=snake_case__	,  return_tensors=snake_case__      )

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

																		lowercase__    :				Optional[int]=	text_generator("This is a test" * 500	,  handle_long_generation="hole"	,  max_new_tokens=20      )
																		# Hole strategy cannot work
																		with self.assertRaises(snake_case__      ):
																								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      ):
												'''simple docstring'''
												import torch

												# Classic `model_kwargs`
												lowercase__    :				List[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      )
												lowercase__    :				List[Any]=	pipe("This is a test"      )
												self.assertEqual(
												    snake_case__	,  [
												        {
												            "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.)
												lowercase__    :				Union[str, Any]=	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      )
												lowercase__    :				int=	pipe("This is a test"      )
												self.assertEqual(
												    snake_case__	,  [
												        {
												            "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
												lowercase__    :				str=	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      )
												lowercase__    :				List[str]=	pipe("This is a test"      )
												self.assertEqual(
												    snake_case__	,  [
												        {
												            "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      ):
												'''simple docstring'''
												import torch

												lowercase__    :				Union[str, 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 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												import torch

												lowercase__    :				Optional[int]=	pipeline(model="hf-internal-testing/tiny-random-bloom"	,  device_map="auto"	,  torch_dtype=torch.floataa      )
												pipe("This is a test"	,  do_sample=snake_case__	,  top_p=0.5      )




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

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

												with CaptureLogger(snake_case__      ) as cl:
																		lowercase__    :				Any=	text_generator(snake_case__	,  max_length=10      )
												self.assertNotIn(snake_case__	,  cl.out      )














"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a			:    List[str]				 =		{
    """configuration_xlm_roberta_xl""": [
        """XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XLMRobertaXLConfig""",
        """XLMRobertaXLOnnxConfig""",
    ],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			a			:    List[str]				 =		[
			    """XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST""",
			    """XLMRobertaXLForCausalLM""",
			    """XLMRobertaXLForMaskedLM""",
			    """XLMRobertaXLForMultipleChoice""",
			    """XLMRobertaXLForQuestionAnswering""",
			    """XLMRobertaXLForSequenceClassification""",
			    """XLMRobertaXLForTokenClassification""",
			    """XLMRobertaXLModel""",
			    """XLMRobertaXLPreTrainedModel""",
			]

if TYPE_CHECKING:
			from .configuration_xlm_roberta_xl import (
			    XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP,
			    XLMRobertaXLConfig,
			    XLMRobertaXLOnnxConfig,
			)

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_xlm_roberta_xl import (
						    XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
						    XLMRobertaXLForCausalLM,
						    XLMRobertaXLForMaskedLM,
						    XLMRobertaXLForMultipleChoice,
						    XLMRobertaXLForQuestionAnswering,
						    XLMRobertaXLForSequenceClassification,
						    XLMRobertaXLForTokenClassification,
						    XLMRobertaXLModel,
						    XLMRobertaXLPreTrainedModel,
						)

else:
			import sys

			a			:    List[str]				 =		_LazyModule(__name__, globals()["""__file__"""], _import_structure)






