
'''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       _lowerCAmelCase   (   unittest.TestCase				):







							'''simple docstring'''

							lowerCAmelCase_ 						=						MODEL_FOR_CAUSAL_LM_MAPPING
							lowerCAmelCase_ 						=						TF_MODEL_FOR_CAUSAL_LM_MAPPING

							@require_torch
							def 	lowercase							(self  )					->       int:
														_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 	lowercase							(self  )					->       Any:
														_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 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       str:
														_snake_case       =  TextGenerationPipeline(model=UpperCAmelCase  ,  tokenizer=UpperCAmelCase  )
														return text_generator, ["This is a test", "Another test"]

							def 	lowercase							(self  )					->       Union[str, Any]:
														_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 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Tuple:
														_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 < 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  )

																					_snake_case       =  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 	lowercase							(self  )					->       str:
														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 	lowercase							(self  )					->       Tuple:
														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 	lowercase							(self  )					->       Optional[Any]:
														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 	lowercase							(self  )					->       int:
														_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=10  ,  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=10  )
														self.assertNotIn(UpperCAmelCase  ,  cl.out  )

'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


__lowerCAmelCase												=	{
    'configuration_efficientformer': [
        'EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'EfficientFormerConfig',
    ]
}

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	['EfficientFormerImageProcessor']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	[
				    'EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'EfficientFormerForImageClassification',
				    'EfficientFormerForImageClassificationWithTeacher',
				    'EfficientFormerModel',
				    'EfficientFormerPreTrainedModel',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	[
				    'TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TFEfficientFormerForImageClassification',
				    'TFEfficientFormerForImageClassificationWithTeacher',
				    'TFEfficientFormerModel',
				    'TFEfficientFormerPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_efficientformer import EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, EfficientFormerConfig

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .image_processing_efficientformer import EfficientFormerImageProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_efficientformer import (
								    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    EfficientFormerForImageClassification,
								    EfficientFormerForImageClassificationWithTeacher,
								    EfficientFormerModel,
								    EfficientFormerPreTrainedModel,
								)
				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_efficientformer import (
								    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFEfficientFormerForImageClassification,
								    TFEfficientFormerForImageClassificationWithTeacher,
								    TFEfficientFormerModel,
								    TFEfficientFormerPreTrainedModel,
								)

else:
				import sys

				__lowerCAmelCase												=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)