


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





  """simple docstring"""




  _lowerCamelCase						=						MODEL_FOR_CAUSAL_LM_MAPPING
  _lowerCamelCase						=						TF_MODEL_FOR_CAUSAL_LM_MAPPING






  @require_torch
  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						pipeline(task="text-generation"    ,						model="sshleifer/tiny-ctrl"    ,						framework="pt"  )
   # Using `do_sample=False` to force deterministic output
   lowerCamelCase_  				=						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@@"
               )
           }
       ]    ,						)

   lowerCamelCase_  				=						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@@"
                   )
               }
           ],
       ]    ,						)

   lowerCamelCase_  				=						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  )},
       ]    ,						)
   lowerCamelCase_  				=						text_generator.model.config.eos_token_id
   lowerCamelCase_  				=						"<pad>"
   lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						pipeline(task="text-generation"    ,						model="sshleifer/tiny-ctrl"    ,						framework="tf"  )

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

   lowerCamelCase_  				=						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 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  ):







   """simple docstring"""
   lowerCamelCase_  				=						TextGenerationPipeline(model=UpperCamelCase    ,						tokenizer=UpperCamelCase  )
   return text_generator, ["This is a test", "Another test"]






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"Hello I believe in"
   lowerCamelCase_  				=						pipeline("text-generation"    ,						model="hf-internal-testing/tiny-random-gpt2"  )
   lowerCamelCase_  				=						text_generator(UpperCamelCase  )
   self.assertEqual(
       UpperCamelCase    ,						[{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}]    ,						)

   lowerCamelCase_  				=						text_generator(UpperCamelCase    ,						stop_sequence=" fe"  )
   self.assertEqual(UpperCamelCase    ,						[{"generated_text": "Hello I believe in fe"}]  )






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase  ):







   """simple docstring"""
   lowerCamelCase_  				=						text_generator.model
   lowerCamelCase_  				=						text_generator.tokenizer

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

   lowerCamelCase_  				=						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"]  )

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

   lowerCamelCase_  				=						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"  )  )

   lowerCamelCase_  				=						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:
    lowerCamelCase_  				=						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  ):
    lowerCamelCase_  				=						text_generator("test"    ,						return_full_text=UpperCamelCase    ,						return_text=UpperCamelCase  )
   with self.assertRaises(UpperCamelCase  ):
    lowerCamelCase_  				=						text_generator("test"    ,						return_full_text=UpperCamelCase    ,						return_tensors=UpperCamelCase  )
   with self.assertRaises(UpperCamelCase  ):
    lowerCamelCase_  				=						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__
   ):
    lowerCamelCase_  				=						text_generator(""  )
    self.assertEqual(UpperCamelCase    ,						[{"generated_text": ANY(UpperCamelCase  )}]  )
   else:
    with self.assertRaises((ValueError, AssertionError)  ):
     lowerCamelCase_  				=						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.
   lowerCamelCase_  				=						["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  )

    lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """simple docstring"""
   import torch

   # Classic `model_kwargs`
   lowerCamelCase_  				=						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  )
   lowerCamelCase_  				=						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.)
   lowerCamelCase_  				=						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  )
   lowerCamelCase_  				=						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
   lowerCamelCase_  				=						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  )
   lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """simple docstring"""
   import torch

   lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """simple docstring"""
   import torch

   lowerCamelCase_  				=						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 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"Hello world"
   lowerCamelCase_  				=						pipeline("text-generation"    ,						model="hf-internal-testing/tiny-random-gpt2"  )
   if text_generator.model.framework == "tf":
    lowerCamelCase_  				=						logging.get_logger("transformers.generation.tf_utils"  )
   else:
    lowerCamelCase_  				=						logging.get_logger("transformers.generation.utils"  )
   lowerCamelCase_  				=						"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:
    lowerCamelCase_  				=						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:
    lowerCamelCase_  				=						text_generator(UpperCamelCase    ,						max_new_tokens=1  )
   self.assertNotIn(UpperCamelCase    ,						cl.out  )

   with CaptureLogger(UpperCamelCase  ) as cl:
    lowerCamelCase_  				=						text_generator(UpperCamelCase    ,						max_length=10  )
   self.assertNotIn(UpperCamelCase    ,						cl.out  )







'''simple docstring'''

def __snake_case      (   UpperCAmelCase_		:		int      ,       UpperCAmelCase_		:		int	):
 return "\n".join(
     F'''{number} * {i} = {number * i}''' for i in range(1      ,       number_of_terms + 1	)	)


if __name__ == "__main__":
     print(multiplication_table(number=5, number_of_terms=10))



