


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				):
 SCREAMING_SNAKE_CASE__ =			MODEL_FOR_CAUSAL_LM_MAPPING
 SCREAMING_SNAKE_CASE__ =			TF_MODEL_FOR_CAUSAL_LM_MAPPING




 @require_torch
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Optional[Any]									=			pipeline(task='''text-generation'''   ,    model='''sshleifer/tiny-ctrl'''   ,    framework='''pt'''       )
       # Using `do_sample=False` to force deterministic output
       a		:int									=			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@@'''
                   )
               }
           ]   ,    )

       a		:Dict									=			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@@'''
                       )
                   }
               ],
           ]   ,    )

       a		:Tuple									=			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       )},
           ]   ,    )
       a		:Dict									=			text_generator.model.config.eos_token_id
       a		:int									=			'''<pad>'''
       a		:Optional[Any]									=			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 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Union[str, Any]									=			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=_lowerCamelCase       )
       self.assertEqual(
           _lowerCamelCase   ,    [
               {
                   '''generated_text''': (
                       '''This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'''
                       ''' please,'''
                   )
               }
           ]   ,    )

       a		:Dict									=			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 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       a		:Dict									=			TextGenerationPipeline(model=_lowerCamelCase   ,    tokenizer=_lowerCamelCase       )
       return text_generator, ["This is a test", "Another test"]




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:int									=			'''Hello I believe in'''
       a		:Union[str, Any]									=			pipeline('''text-generation'''   ,    model='''hf-internal-testing/tiny-random-gpt2'''       )
       a		:Dict									=			text_generator(_lowerCamelCase       )
       self.assertEqual(
           _lowerCamelCase   ,    [{'''generated_text''': '''Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'''}]   ,    )

       a		:int									=			text_generator(_lowerCamelCase   ,    stop_sequence=''' fe'''       )
       self.assertEqual(_lowerCamelCase   ,    [{'''generated_text''': '''Hello I believe in fe'''}]       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       a		:List[Any]									=			text_generator.model
       a		:List[Any]									=			text_generator.tokenizer

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

       a		:Optional[int]									=			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''']       )

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

       a		:str									=			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'''       )       )

       a		:List[Any]									=			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:
             a		:str									=			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       ):
             a		:List[str]									=			text_generator('''test'''   ,    return_full_text=_lowerCamelCase   ,    return_text=_lowerCamelCase       )
       with self.assertRaises(_lowerCamelCase       ):
             a		:Optional[int]									=			text_generator('''test'''   ,    return_full_text=_lowerCamelCase   ,    return_tensors=_lowerCamelCase       )
       with self.assertRaises(_lowerCamelCase       ):
             a		:Optional[int]									=			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__
       ):
             a		:List[Any]									=			text_generator(''''''       )
             self.assertEqual(_lowerCamelCase   ,    [{'''generated_text''': ANY(_lowerCamelCase       )}]       )
       else:
             with self.assertRaises((ValueError, AssertionError)       ):
                   a		:List[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.
       a		:int									=			['''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       )

             a		:List[Any]									=			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 			SCREAMING_SNAKE_CASE__							(						self       ):
       import torch

       # Classic `model_kwargs`
       a		:int									=			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		:Optional[Any]									=			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.)
       a		:Tuple									=			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		:int									=			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
       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[int]									=			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 			SCREAMING_SNAKE_CASE__							(						self       ):
       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       ):
       import torch

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

       with CaptureLogger(_lowerCamelCase       ) as cl:
             a		:Tuple									=			text_generator(_lowerCamelCase   ,    max_length=10       )
       self.assertNotIn(_lowerCamelCase   ,    cl.out       )









def 							__lowerCamelCase		(					UpperCAmelCase_		:						int					,    UpperCAmelCase_		:						int		):




      """simple docstring"""





      while b:
            a				,							a		:int									=			b, a % b
      return a
def 							__lowerCamelCase		(					UpperCAmelCase_		:						int					,    UpperCAmelCase_		:						int		):




      """simple docstring"""





      return a if b == 0 else euclidean_gcd_recursive(UpperCAmelCase_					,    a % b		)
def 							__lowerCamelCase		(					):




      """simple docstring"""





      print(F'''euclidean_gcd(3, 5) = {euclidean_gcd(3					,    5		)}'''		)
      print(F'''euclidean_gcd(5, 3) = {euclidean_gcd(5					,    3		)}'''		)
      print(F'''euclidean_gcd(1, 3) = {euclidean_gcd(1					,    3		)}'''		)
      print(F'''euclidean_gcd(3, 6) = {euclidean_gcd(3					,    6		)}'''		)
      print(F'''euclidean_gcd(6, 3) = {euclidean_gcd(6					,    3		)}'''		)

      print(F'''euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3					,    5		)}'''		)
      print(F'''euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5					,    3		)}'''		)
      print(F'''euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1					,    3		)}'''		)
      print(F'''euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3					,    6		)}'''		)
      print(F'''euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6					,    3		)}'''		)


if __name__ == "__main__":
     main()





