


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







       @require_torch
       def 		snake_case_	(			self: Union[str, Any]					):






            '''simple docstring'''




            __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=snake_case__					)
            self.assertEqual(
                snake_case__,[
                    {
                        '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(
                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@@'
                            )
                        }
                    ],
                ],)

            __UpperCamelCase =			text_generator('This is a test',do_sample=snake_case__,num_return_sequences=2,return_tensors=snake_case__					)
            self.assertEqual(
                snake_case__,[
                    {'generated_token_ids': ANY(snake_case__					)},
                    {'generated_token_ids': ANY(snake_case__					)},
                ],)
            __UpperCamelCase =			text_generator.model.config.eos_token_id
            __UpperCamelCase =			'<pad>'
            __UpperCamelCase =			text_generator(
                ['This is a test', 'This is a second test'],do_sample=snake_case__,num_return_sequences=2,batch_size=2,return_tensors=snake_case__,)
            self.assertEqual(
                snake_case__,[
                    [
                        {'generated_token_ids': ANY(snake_case__					)},
                        {'generated_token_ids': ANY(snake_case__					)},
                    ],
                    [
                        {'generated_token_ids': ANY(snake_case__					)},
                        {'generated_token_ids': ANY(snake_case__					)},
                    ],
                ],)







       @require_tf
       def 		snake_case_	(			self: Any					):






            '''simple docstring'''




            __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=snake_case__					)
            self.assertEqual(
                snake_case__,[
                    {
                        '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=snake_case__					)
            self.assertEqual(
                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 		snake_case_	(			self: Any,A_: Optional[Any],A_: Tuple,A_: List[Any]					):






            '''simple docstring'''




            __UpperCamelCase =			TextGenerationPipeline(model=snake_case__,tokenizer=snake_case__					)
            return text_generator, ["This is a test", "Another test"]







       def 		snake_case_	(			self: Any					):






            '''simple docstring'''




            __UpperCamelCase =			'Hello I believe in'
            __UpperCamelCase =			pipeline('text-generation',model='hf-internal-testing/tiny-random-gpt2'					)
            __UpperCamelCase =			text_generator(snake_case__					)
            self.assertEqual(
                snake_case__,[{'generated_text': 'Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'}],)

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







       def 		snake_case_	(			self: Tuple,A_: int,A_: Union[str, Any]					):






            '''simple docstring'''




            __UpperCamelCase =			text_generator.model
            __UpperCamelCase =			text_generator.tokenizer

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

            __UpperCamelCase =			text_generator('This is a test',return_full_text=snake_case__					)
            self.assertEqual(snake_case__,[{'generated_text': ANY(snake_case__					)}]					)
            self.assertNotIn('This is a test',outputs[0]['generated_text']					)

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

            __UpperCamelCase =			text_generator('This is a test',return_full_text=snake_case__					)
            self.assertEqual(snake_case__,[{'generated_text': ANY(snake_case__					)}]					)
            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=snake_case__					)
            self.assertEqual(
                snake_case__,[
                    [{'generated_text': ANY(snake_case__					)}, {'generated_text': ANY(snake_case__					)}],
                    [{'generated_text': ANY(snake_case__					)}, {'generated_text': ANY(snake_case__					)}],
                ],)

            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=snake_case__					)
                 self.assertEqual(
                     snake_case__,[
                         [{'generated_text': ANY(snake_case__					)}, {'generated_text': ANY(snake_case__					)}],
                         [{'generated_text': ANY(snake_case__					)}, {'generated_text': ANY(snake_case__					)}],
                     ],)

            with self.assertRaises(snake_case__					):
                 __UpperCamelCase =			text_generator('test',return_full_text=snake_case__,return_text=snake_case__					)
            with self.assertRaises(snake_case__					):
                 __UpperCamelCase =			text_generator('test',return_full_text=snake_case__,return_tensors=snake_case__					)
            with self.assertRaises(snake_case__					):
                 __UpperCamelCase =			text_generator('test',return_text=snake_case__,return_tensors=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__
            ):
                 __UpperCamelCase =			text_generator(''					)
                 self.assertEqual(snake_case__,[{'generated_text': ANY(snake_case__					)}]					)
            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(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 		snake_case_	(			self: str					):






            '''simple docstring'''




            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(
                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.)
            __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(
                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
            __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(
                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 		snake_case_	(			self: Optional[int]					):






            '''simple docstring'''




            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 		snake_case_	(			self: Union[str, Any]					):






            '''simple docstring'''




            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=snake_case__,top_p=0.5					)







       def 		snake_case_	(			self: Union[str, Any]					):






            '''simple docstring'''




            __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(snake_case__					) as cl:
                 __UpperCamelCase =			text_generator(snake_case__,max_length=10,max_new_tokens=1					)
            self.assertIn(snake_case__,cl.out					)

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

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



"""simple docstring"""




def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__  ):





		"""simple docstring"""




		return abs(lowerCamelCase__  ) if a == 0 else greatest_common_divisor(b % a      ,	lowerCamelCase__  )







def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__  ):





		"""simple docstring"""




		while y:  # --> when y=0 then loop will terminate and return x as final GCD.
				lowerCAmelCase__ ,       lowerCAmelCase__   = y, x % y
		return abs(lowerCamelCase__  )







def 				_UpperCAmelCase		(							):





		"""simple docstring"""




		try:
				lowerCAmelCase__   = input("""Enter two integers separated by comma (,): """  ).split(""","""  )
				lowerCAmelCase__   = int(nums[0]  )
				lowerCAmelCase__   = int(nums[1]  )
				print(
				    f"""greatest_common_divisor({num_a}, {num_a}) = """
				    f"""{greatest_common_divisor(lowerCamelCase__      ,	lowerCamelCase__  )}"""  )
				print(f"""By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(lowerCamelCase__      ,	lowerCamelCase__  )}"""  )
		except (IndexError, UnboundLocalError, ValueError):
				print("""Wrong input"""  )


if __name__ == "__main__":
			main()




