





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





     """simple docstring"""



     __UpperCamelCase    			=   MODEL_FOR_CAUSAL_LM_MAPPING
     __UpperCamelCase    			=   TF_MODEL_FOR_CAUSAL_LM_MAPPING



     @require_torch
     def   SCREAMING_SNAKE_CASE						(							self				:List[Any]     ):





        '''simple docstring'''




        A_    : Dict								=	pipeline(task="text-generation"	,					model="sshleifer/tiny-ctrl"	,					framework="pt"     )
        # Using `do_sample=False` to force deterministic output
        A_    : Optional[Any]								=	text_generator("This is a test"	,					do_sample=SCREAMING_SNAKE_CASE_     )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_	,					[
                {
                    "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(
            SCREAMING_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@@"
                        )
                    }
                ],
            ]	,					)

        A_    : List[Any]								=	text_generator("This is a test"	,					do_sample=SCREAMING_SNAKE_CASE_	,					num_return_sequences=2	,					return_tensors=SCREAMING_SNAKE_CASE_     )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_	,					[
                {"generated_token_ids": ANY(SCREAMING_SNAKE_CASE_     )},
                {"generated_token_ids": ANY(SCREAMING_SNAKE_CASE_     )},
            ]	,					)
        A_    : List[str]								=	text_generator.model.config.eos_token_id
        A_    : List[Any]								=	'<pad>'
        A_    : Dict								=	text_generator(
            ["This is a test", "This is a second test"]	,					do_sample=SCREAMING_SNAKE_CASE_	,					num_return_sequences=2	,					batch_size=2	,					return_tensors=SCREAMING_SNAKE_CASE_	,					)
        self.assertEqual(
            SCREAMING_SNAKE_CASE_	,					[
                [
                    {"generated_token_ids": ANY(SCREAMING_SNAKE_CASE_     )},
                    {"generated_token_ids": ANY(SCREAMING_SNAKE_CASE_     )},
                ],
                [
                    {"generated_token_ids": ANY(SCREAMING_SNAKE_CASE_     )},
                    {"generated_token_ids": ANY(SCREAMING_SNAKE_CASE_     )},
                ],
            ]	,					)



     @require_tf
     def   SCREAMING_SNAKE_CASE						(							self				:Dict     ):





        '''simple docstring'''




        A_    : Dict								=	pipeline(task="text-generation"	,					model="sshleifer/tiny-ctrl"	,					framework="tf"     )

        # Using `do_sample=False` to force deterministic output
        A_    : Tuple								=	text_generator("This is a test"	,					do_sample=SCREAMING_SNAKE_CASE_     )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_	,					[
                {
                    "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=SCREAMING_SNAKE_CASE_     )
        self.assertEqual(
            SCREAMING_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   SCREAMING_SNAKE_CASE						(							self				:int	,					snake_case				:List[str]	,					snake_case				:Any	,					snake_case				:int     ):





        '''simple docstring'''




        A_    : int								=	TextGenerationPipeline(model=SCREAMING_SNAKE_CASE_	,					tokenizer=SCREAMING_SNAKE_CASE_     )
        return text_generator, ["This is a test", "Another test"]



     def   SCREAMING_SNAKE_CASE						(							self				:List[str]     ):





        '''simple docstring'''




        A_    : Tuple								=	'Hello I believe in'
        A_    : Optional[Any]								=	pipeline("text-generation"	,					model="hf-internal-testing/tiny-random-gpt2"     )
        A_    : Union[str, Any]								=	text_generator(SCREAMING_SNAKE_CASE_     )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_	,					[{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}]	,					)

        A_    : Optional[int]								=	text_generator(SCREAMING_SNAKE_CASE_	,					stop_sequence=" fe"     )
        self.assertEqual(SCREAMING_SNAKE_CASE_	,					[{"generated_text": "Hello I believe in fe"}]     )



     def   SCREAMING_SNAKE_CASE						(							self				:int	,					snake_case				:List[Any]	,					snake_case				:Tuple     ):





        '''simple docstring'''




        A_    : List[Any]								=	text_generator.model
        A_    : Tuple								=	text_generator.tokenizer

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

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

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

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

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

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

        with self.assertRaises(SCREAMING_SNAKE_CASE_     ):
           A_    : Tuple								=	text_generator("test"	,					return_full_text=SCREAMING_SNAKE_CASE_	,					return_text=SCREAMING_SNAKE_CASE_     )
        with self.assertRaises(SCREAMING_SNAKE_CASE_     ):
           A_    : str								=	text_generator("test"	,					return_full_text=SCREAMING_SNAKE_CASE_	,					return_tensors=SCREAMING_SNAKE_CASE_     )
        with self.assertRaises(SCREAMING_SNAKE_CASE_     ):
           A_    : List[Any]								=	text_generator("test"	,					return_text=SCREAMING_SNAKE_CASE_	,					return_tensors=SCREAMING_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__
        ):
           A_    : str								=	text_generator(""     )
           self.assertEqual(SCREAMING_SNAKE_CASE_	,					[{"generated_text": ANY(SCREAMING_SNAKE_CASE_     )}]     )
        else:
           with self.assertRaises((ValueError, AssertionError)     ):
              A_    : Dict								=	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_    : str								=	['RwkvForCausalLM', 'XGLMForCausalLM', 'GPTNeoXForCausalLM']
        if (
            tokenizer.model_max_length < 10_000
            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[Any]								=	text_generator("This is a test" * 500	,					handle_long_generation="hole"	,					max_new_tokens=20     )
           # Hole strategy cannot work
           with self.assertRaises(SCREAMING_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   SCREAMING_SNAKE_CASE						(							self				:List[str]     ):





        '''simple docstring'''




        import torch

        # Classic `model_kwargs`
        A_    : Dict								=	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(
            SCREAMING_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.)
        A_    : str								=	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_    : Any								=	pipe("This is a test"     )
        self.assertEqual(
            SCREAMING_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
        A_    : List[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     )
        A_    : Optional[Any]								=	pipe("This is a test"     )
        self.assertEqual(
            SCREAMING_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   SCREAMING_SNAKE_CASE						(							self				:str     ):





        '''simple docstring'''




        import torch

        A_    : int								=	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				:str     ):





        '''simple docstring'''




        import torch

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





     def   SCREAMING_SNAKE_CASE						(							self				:List[str]     ):





        '''simple docstring'''




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

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

        with CaptureLogger(SCREAMING_SNAKE_CASE_     ) as cl:
           A_    : int								=	text_generator(SCREAMING_SNAKE_CASE_	,					max_length=10     )
        self.assertNotIn(SCREAMING_SNAKE_CASE_	,					cl.out     )





"""simple docstring"""







import re

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str						)						->   list:

  """simple docstring"""




  return [char.split() for char in re.split(R'[^ a-z A-Z 0-9 \s]'    ,   str_						)]

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str						)						->   str:

  """simple docstring"""




  lowerCAmelCase_   :				str								= split_input(str_						)
  return "".join(
      [''.join([char.capitalize() for char in sub_str]						) for sub_str in string_split]						)

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str    ,   lowerCAmelCase__      :				bool    ,   lowerCAmelCase__      :				str						)						->   str:

  """simple docstring"""




  try:
    lowerCAmelCase_   :				int								= split_input(lowerCAmelCase__						)
    if upper:
      lowerCAmelCase_   :				Optional[int]								= ''.join(
          [
              separator.join([char.upper() for char in sub_str]						)
              for sub_str in string_split
          ]						)
    else:
      lowerCAmelCase_   :				Any								= ''.join(
          [
              separator.join([char.lower() for char in sub_str]						)
              for sub_str in string_split
          ]						)
    return res_str
  except IndexError:
    return "not valid string"

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str						)						->   str:

  """simple docstring"""




  return to_simple_case(lowerCAmelCase__						)

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str						)						->   str:

  """simple docstring"""




  try:
    lowerCAmelCase_   :				Dict								= to_simple_case(lowerCAmelCase__						)
    return res_str[0].lower() + res_str[1:]
  except IndexError:
    return "not valid string"

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str    ,   lowerCAmelCase__      :				bool						)						->   str:

  """simple docstring"""




  return to_complex_case(lowerCAmelCase__    ,   lowerCAmelCase__    ,   '_'						)

def 				UpperCamelCase_    (    lowerCAmelCase__      :				str    ,   lowerCAmelCase__      :				bool						)						->   str:

  """simple docstring"""




  return to_complex_case(lowerCAmelCase__    ,   lowerCAmelCase__    ,   '-'						)


if __name__ == "__main__":
     __import__("""doctest""").testmod()





