


"""simple docstring"""
import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TextaTextGenerationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch
from transformers.utils import is_torch_available

from .test_pipelines_common import ANY


if is_torch_available():
			import torch



@is_pipeline_test
class 			_UpperCAmelCase (							unittest.TestCase				):






		'''simple docstring'''

		lowerCamelCase__				=MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
		lowerCamelCase__				=TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING



		def 				SCREAMING_SNAKE_CASE  (self				,       a_				,       a_				,       a_					):





			'''simple docstring'''

			__snake_case	:						Union[str, Any]						=				TextaTextGenerationPipeline(model=a_				,       tokenizer=a_					)
			return generator, ["Something to write", "Something else"]



		def 				SCREAMING_SNAKE_CASE  (self				,       a_				,       a_					):





			'''simple docstring'''

			__snake_case	:						Union[str, Any]						=				generator('''Something there'''					)
			self.assertEqual(a_				,       [{'''generated_text''': ANY(a_					)}]					)
			# These are encoder decoder, they don't just append to incoming string
			self.assertFalse(outputs[0]['''generated_text'''].startswith('''Something there'''					)					)

			__snake_case	:						List[Any]						=				generator(['''This is great !''', '''Something else''']				,       num_return_sequences=2				,       do_sample=a_					)
			self.assertEqual(
			    a_				,       [
			        [{'''generated_text''': ANY(a_					)}, {'''generated_text''': ANY(a_					)}],
			        [{'''generated_text''': ANY(a_					)}, {'''generated_text''': ANY(a_					)}],
			    ]				,       )

			__snake_case	:						Optional[int]						=				generator(
			    ['''This is great !''', '''Something else''']				,       num_return_sequences=2				,       batch_size=2				,       do_sample=a_					)
			self.assertEqual(
			    a_				,       [
			        [{'''generated_text''': ANY(a_					)}, {'''generated_text''': ANY(a_					)}],
			        [{'''generated_text''': ANY(a_					)}, {'''generated_text''': ANY(a_					)}],
			    ]				,       )

			with self.assertRaises(a_					):
				generator(4					)



		@require_torch
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Any						=				pipeline('''text2text-generation'''				,       model='''patrickvonplaten/t5-tiny-random'''				,       framework='''pt'''					)
			# do_sample=False necessary for reproducibility
			__snake_case	:						int						=				generator('''Something there'''				,       do_sample=a_					)
			self.assertEqual(a_				,       [{'''generated_text''': ''''''}]					)

			__snake_case	:						Optional[int]						=				3
			__snake_case	:						int						=				generator(
			    '''Something there'''				,       num_return_sequences=a_				,       num_beams=a_				,       )
			__snake_case	:						Dict						=				[
			    {'''generated_text''': '''Beide Beide Beide Beide Beide Beide Beide Beide Beide'''},
			    {'''generated_text''': '''Beide Beide Beide Beide Beide Beide Beide Beide'''},
			    {'''generated_text''': ''''''},
			]
			self.assertEqual(a_				,       a_					)

			__snake_case	:						List[Any]						=				generator('''This is a test'''				,       do_sample=a_				,       num_return_sequences=2				,       return_tensors=a_					)
			self.assertEqual(
			    a_				,       [
			        {'''generated_token_ids''': ANY(torch.Tensor					)},
			        {'''generated_token_ids''': ANY(torch.Tensor					)},
			    ]				,       )
			__snake_case	:						Dict						=				generator.model.config.eos_token_id
			__snake_case	:						Any						=				'''<pad>'''
			__snake_case	:						Tuple						=				generator(
			    ['''This is a test''', '''This is a second test''']				,       do_sample=a_				,       num_return_sequences=2				,       batch_size=2				,       return_tensors=a_				,       )
			self.assertEqual(
			    a_				,       [
			        [
			            {'''generated_token_ids''': ANY(torch.Tensor					)},
			            {'''generated_token_ids''': ANY(torch.Tensor					)},
			        ],
			        [
			            {'''generated_token_ids''': ANY(torch.Tensor					)},
			            {'''generated_token_ids''': ANY(torch.Tensor					)},
			        ],
			    ]				,       )



		@require_tf
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Optional[int]						=				pipeline('''text2text-generation'''				,       model='''patrickvonplaten/t5-tiny-random'''				,       framework='''tf'''					)
			# do_sample=False necessary for reproducibility
			__snake_case	:						Union[str, Any]						=				generator('''Something there'''				,       do_sample=a_					)
			self.assertEqual(a_				,       [{'''generated_text''': ''''''}]					)









"""simple docstring"""
import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()



@slow
@require_torch_gpu
class 			_UpperCAmelCase (							unittest.TestCase				):






		'''simple docstring'''

		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Tuple						=				StableDiffusionKDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''					)
			__snake_case	:						List[str]						=				sd_pipe.to(a_					)
			sd_pipe.set_progress_bar_config(disable=a_					)

			sd_pipe.set_scheduler('''sample_euler'''					)

			__snake_case	:						Tuple						=				'''A painting of a squirrel eating a burger'''
			__snake_case	:						str						=				torch.manual_seed(0					)
			__snake_case	:						int						=				sd_pipe([prompt]				,       generator=a_				,       guidance_scale=9.0				,       num_inference_steps=20				,       output_type='''np'''					)

			__snake_case	:						List[str]						=				output.images

			__snake_case	:						Tuple						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 5_12, 5_12, 3)
			__snake_case	:						Dict						=				np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Optional[Any]						=				StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''					)
			__snake_case	:						Union[str, Any]						=				sd_pipe.to(a_					)
			sd_pipe.set_progress_bar_config(disable=a_					)

			sd_pipe.set_scheduler('''sample_euler'''					)

			__snake_case	:						str						=				'''A painting of a squirrel eating a burger'''
			__snake_case	:						List[str]						=				torch.manual_seed(0					)
			__snake_case	:						Dict						=				sd_pipe([prompt]				,       generator=a_				,       guidance_scale=9.0				,       num_inference_steps=20				,       output_type='''np'''					)

			__snake_case	:						Any						=				output.images

			__snake_case	:						Tuple						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 5_12, 5_12, 3)
			__snake_case	:						Tuple						=				np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]					)

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Any						=				StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''					)
			__snake_case	:						Union[str, Any]						=				sd_pipe.to(a_					)
			sd_pipe.set_progress_bar_config(disable=a_					)

			sd_pipe.set_scheduler('''sample_dpmpp_2m'''					)

			__snake_case	:						int						=				'''A painting of a squirrel eating a burger'''
			__snake_case	:						Optional[Any]						=				torch.manual_seed(0					)
			__snake_case	:						Dict						=				sd_pipe(
			    [prompt]				,       generator=a_				,       guidance_scale=7.5				,       num_inference_steps=15				,       output_type='''np'''				,       use_karras_sigmas=a_				,       )

			__snake_case	:						Optional[int]						=				output.images

			__snake_case	:						Any						=				image[0, -3:, -3:, -1]

			assert image.shape == (1, 5_12, 5_12, 3)
			__snake_case	:						Any						=				np.array(
			    [0.1138_1689, 0.1211_2921, 0.138_9457, 0.1254_9606, 0.124_4964, 0.1083_1517, 0.1156_2866, 0.1086_7816, 0.1049_9048]					)

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





