




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		):
      UpperCAmelCase_        =		MODEL_FOR_CAUSAL_LM_MAPPING
      UpperCAmelCase_        =		TF_MODEL_FOR_CAUSAL_LM_MAPPING
      @require_torch
      def 	UpperCAmelCase_						(			self   :List[Any]      )     ->			List[str]:
       UpperCAmelCase__							 =						pipeline(task="text-generation" ,      model="sshleifer/tiny-ctrl" ,      framework="pt"      )
       # Using `do_sample=False` to force deterministic output
       UpperCAmelCase__							 =						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@@"
                   )
               }
           ] ,      )

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

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

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

       UpperCAmelCase__							 =						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 	UpperCAmelCase_						(			self   :int ,      lowerCamelCase   :List[Any] ,      lowerCamelCase   :List[str] ,      lowerCamelCase   :List[Any]      )     ->			Union[str, Any]:
       UpperCAmelCase__							 =						TextGenerationPipeline(model=lowerCamelCase ,      tokenizer=lowerCamelCase      )
       return text_generator, ["This is a test", "Another test"]
      def 	UpperCAmelCase_						(			self   :Union[str, Any]      )     ->			Dict:
       UpperCAmelCase__							 =						"Hello I believe in"
       UpperCAmelCase__							 =						pipeline("text-generation" ,      model="hf-internal-testing/tiny-random-gpt2"      )
       UpperCAmelCase__							 =						text_generator(lowerCamelCase      )
       self.assertEqual(
           lowerCamelCase ,      [{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}] ,      )

       UpperCAmelCase__							 =						text_generator(lowerCamelCase ,      stop_sequence=" fe"      )
       self.assertEqual(lowerCamelCase ,      [{"generated_text": "Hello I believe in fe"}]      )
      def 	UpperCAmelCase_						(			self   :Dict ,      lowerCamelCase   :Optional[Any] ,      lowerCamelCase   :Dict      )     ->			Any:
       UpperCAmelCase__							 =						text_generator.model
       UpperCAmelCase__							 =						text_generator.tokenizer

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

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

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

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

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

        UpperCAmelCase__							 =						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 	UpperCAmelCase_						(			self   :Tuple      )     ->			Optional[Any]:
       import torch

       # Classic `model_kwargs`
       UpperCAmelCase__							 =						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      )
       UpperCAmelCase__							 =						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.)
       UpperCAmelCase__							 =						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      )
       UpperCAmelCase__							 =						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
       UpperCAmelCase__							 =						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      )
       UpperCAmelCase__							 =						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 	UpperCAmelCase_						(			self   :int      )     ->			int:
       import torch

       UpperCAmelCase__							 =						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   :Union[str, Any]      )     ->			Optional[Any]:
       import torch

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

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











from __future__ import annotations



def 						lowerCAmelCase		(		_lowerCAmelCase							:   int = 4	):




 """simple docstring"""







 UpperCAmelCase__							 =						abs(_lowerCAmelCase	) or 4
 return [[1 + x + y * row_size for x in range(_lowerCAmelCase	)] for y in range(_lowerCAmelCase	)]



def 						lowerCAmelCase		(		_lowerCAmelCase							:   list[list[int]]	):




 """simple docstring"""







 return reverse_row(transpose(_lowerCAmelCase	)	)
 # OR.. transpose(reverse_column(matrix))



def 						lowerCAmelCase		(		_lowerCAmelCase							:   list[list[int]]	):




 """simple docstring"""







 return reverse_row(reverse_column(_lowerCAmelCase	)	)
 # OR.. reverse_column(reverse_row(matrix))



def 						lowerCAmelCase		(		_lowerCAmelCase							:   list[list[int]]	):




 """simple docstring"""







 return reverse_column(transpose(_lowerCAmelCase	)	)
 # OR.. transpose(reverse_row(matrix))



def 						lowerCAmelCase		(		_lowerCAmelCase							:   list[list[int]]	):




 """simple docstring"""







 UpperCAmelCase__							 =						[list(_lowerCAmelCase	) for x in zip(*_lowerCAmelCase	)]
 return matrix



def 						lowerCAmelCase		(		_lowerCAmelCase							:   list[list[int]]	):




 """simple docstring"""







 UpperCAmelCase__							 =						matrix[::-1]
 return matrix



def 						lowerCAmelCase		(		_lowerCAmelCase							:   list[list[int]]	):




 """simple docstring"""







 UpperCAmelCase__							 =						[x[::-1] for x in matrix]
 return matrix



def 						lowerCAmelCase		(		_lowerCAmelCase							:   list[list[int]]	):




 """simple docstring"""







 for i in matrix:
  print(*_lowerCAmelCase	)


if __name__ == "__main__":
  _lowerCAmelCase						:   Optional[int]		=   make_matrix()
  print("\norigin:\n")
  print_matrix(matrix)
  print("\nrotate 90 counterclockwise:\n")
  print_matrix(rotate_aa(matrix))

  _lowerCAmelCase						:   Union[str, Any]		=   make_matrix()
  print("\norigin:\n")
  print_matrix(matrix)
  print("\nrotate 180:\n")
  print_matrix(rotate_aaa(matrix))

  _lowerCAmelCase						:   Optional[int]		=   make_matrix()
  print("\norigin:\n")
  print_matrix(matrix)
  print("\nrotate 270 counterclockwise:\n")
  print_matrix(rotate_aaa(matrix))





