


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



     """simple docstring"""






     __magic_name__           =     MODEL_FOR_CAUSAL_LM_MAPPING
     __magic_name__           =     TF_MODEL_FOR_CAUSAL_LM_MAPPING







     @require_torch
     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				str       =							pipeline(task='text-generation'   ,						model='sshleifer/tiny-ctrl'   ,						framework='pt' )
            # Using `do_sample=False` to force deterministic output
            _lowerCAmelCase     :				Union[str, Any]       =							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@@'
                        )
                    }
                ]   ,						)

            _lowerCAmelCase     :				List[Any]       =							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@@'
                            )
                        }
                    ],
                ]   ,						)

            _lowerCAmelCase     :				int       =							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__ )},
                ]   ,						)
            _lowerCAmelCase     :				Union[str, Any]       =							text_generator.model.config.eos_token_id
            _lowerCAmelCase     :				List[str]       =							'<pad>'
            _lowerCAmelCase     :				List[str]       =							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 a						(			self ):

            '''simple docstring'''

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

            # Using `do_sample=False` to force deterministic output
            _lowerCAmelCase     :				List[str]       =							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,'
                        )
                    }
                ]   ,						)

            _lowerCAmelCase     :				Optional[int]       =							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 a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				List[str]       =							TextGenerationPipeline(model=snake_case__   ,						tokenizer=snake_case__ )
            return text_generator, ["This is a test", "Another test"]







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				List[str]       =							'Hello I believe in'
            _lowerCAmelCase     :				str       =							pipeline('text-generation'   ,						model='hf-internal-testing/tiny-random-gpt2' )
            _lowerCAmelCase     :				Optional[int]       =							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'}]   ,						)

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







     def a						(			self   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				Tuple       =							text_generator.model
            _lowerCAmelCase     :				int       =							text_generator.tokenizer

            _lowerCAmelCase     :				Optional[Any]       =							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' ) )

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

            _lowerCAmelCase     :				List[Any]       =							pipeline(task='text-generation'   ,						model=snake_case__   ,						tokenizer=snake_case__   ,						return_full_text=snake_case__ )
            _lowerCAmelCase     :				Tuple       =							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'] )

            _lowerCAmelCase     :				Any       =							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' ) )

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

            '''simple docstring'''

            import torch

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

            '''simple docstring'''

            import torch

            _lowerCAmelCase     :				List[str]       =							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 a						(			self ):

            '''simple docstring'''

            import torch

            _lowerCAmelCase     :				Optional[Any]       =							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 a						(			self ):

            '''simple docstring'''

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

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





'''simple docstring'''







import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionTextToImagePipeline
from diffusers.utils.testing_utils import nightly, require_torch_gpu, torch_device


lowerCAmelCase     :  str											=    False
class 						UpperCamelCase__       (			unittest.TestCase						):



     """simple docstring"""






     pass
@nightly
@require_torch_gpu
class 						UpperCamelCase__       (			unittest.TestCase						):



     """simple docstring"""






     def a						(			self ):

            '''simple docstring'''

            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				List[str]       =							VersatileDiffusionTextToImagePipeline.from_pretrained('shi-labs/versatile-diffusion' )
            # remove text_unet
            pipe.remove_unused_weights()
            pipe.to(snake_case__ )
            pipe.set_progress_bar_config(disable=snake_case__ )

            _lowerCAmelCase     :				Any       =							'A painting of a squirrel eating a burger '
            _lowerCAmelCase     :				List[Any]       =							torch.manual_seed(0 )
            _lowerCAmelCase     :				Any       =							pipe(
                prompt=snake_case__   ,						generator=snake_case__   ,						guidance_scale=7.5   ,						num_inference_steps=2   ,						output_type='numpy' ).images

            with tempfile.TemporaryDirectory() as tmpdirname:
                   pipe.save_pretrained(snake_case__ )
                   _lowerCAmelCase     :				Any       =							VersatileDiffusionTextToImagePipeline.from_pretrained(snake_case__ )
            pipe.to(snake_case__ )
            pipe.set_progress_bar_config(disable=snake_case__ )

            _lowerCAmelCase     :				Optional[int]       =							generator.manual_seed(0 )
            _lowerCAmelCase     :				Tuple       =							pipe(
                prompt=snake_case__   ,						generator=snake_case__   ,						guidance_scale=7.5   ,						num_inference_steps=2   ,						output_type='numpy' ).images

            assert np.abs(image - new_image ).sum() < 1E-5, "Models don't have the same forward pass"







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Union[str, Any]       =							VersatileDiffusionTextToImagePipeline.from_pretrained(
                'shi-labs/versatile-diffusion'   ,						torch_dtype=torch.floataa )
            pipe.to(snake_case__ )
            pipe.set_progress_bar_config(disable=snake_case__ )

            _lowerCAmelCase     :				Dict       =							'A painting of a squirrel eating a burger '
            _lowerCAmelCase     :				Any       =							torch.manual_seed(0 )
            _lowerCAmelCase     :				int       =							pipe(
                prompt=snake_case__   ,						generator=snake_case__   ,						guidance_scale=7.5   ,						num_inference_steps=50   ,						output_type='numpy' ).images

            _lowerCAmelCase     :				Optional[int]       =							image[0, 253:256, 253:256, -1]

            assert image.shape == (1, 512, 512, 3)
            _lowerCAmelCase     :				Dict       =							np.array([0.3367, 0.3169, 0.2656, 0.3870, 0.4790, 0.3796, 0.4009, 0.4878, 0.4778] )

            assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2

