





"""simple docstring"""





import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionImageVariationPipeline
from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device


__A											=						False






class    _lowerCAmelCase  (	unittest.TestCase			):
       """simple docstring"""




       pass






@slow
@require_torch_gpu
class    _lowerCAmelCase  (	unittest.TestCase			):
       """simple docstring"""




       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Optional[Any]											=				VersatileDiffusionImageVariationPipeline.from_pretrained('shi-labs/versatile-diffusion' )
         pipe.to(__UpperCAmelCase )
         pipe.set_progress_bar_config(disable=__UpperCAmelCase )

         lowerCAmelCase__     :List[Any]											=				load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
         lowerCAmelCase__     :Union[str, Any]											=				torch.manual_seed(0 )
         lowerCAmelCase__     :Any											=				pipe(
             image=__UpperCAmelCase       ,					generator=__UpperCAmelCase       ,					guidance_scale=7.5       ,					num_inference_steps=5_0       ,					output_type='numpy'       ,					).images

         lowerCAmelCase__     :Any											=				image[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1]

         assert image.shape == (1, 5_1_2, 5_1_2, 3)
         lowerCAmelCase__     :List[str]											=				np.array([0.04_41, 0.04_69, 0.05_07, 0.05_75, 0.06_32, 0.06_50, 0.08_65, 0.09_09, 0.09_45] )

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



import unittest

import numpy as np
import torch

from .utils_summarization import build_mask, compute_token_type_ids, process_story, truncate_or_pad







class 					lowercase							(			unittest.TestCase     ):




				def        a				(   self			):
											snake_case_     							=       10




				def        a				(   self			):
											snake_case_     							=       [1, 2, 3, 4]
											snake_case_     							=       [1, 2, 3, 4, 0, 0, 0, 0, 0, 0]
											self.assertEqual(truncate_or_pad(snake_case ,  self.block_size ,  0			) ,  snake_case			)




				def        a				(   self			):
											snake_case_     							=       [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
											snake_case_     							=       [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
											self.assertEqual(truncate_or_pad(snake_case ,  self.block_size ,  0			) ,  snake_case			)




				def        a				(   self			):
											snake_case_     							=       [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
											snake_case_     							=       [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
											self.assertEqual(truncate_or_pad(snake_case ,  self.block_size ,  0			) ,  snake_case			)




				def        a				(   self			):
											snake_case_     							=       'It was the year of Our Lord one thousand seven hundred and\n        seventy-five.\n\nSpiritual revelations were conceded to England at that\n        favoured period, as at this.'
											snake_case_							,       snake_case_     							=       process_story(snake_case			)
											self.assertEqual(snake_case ,  []			)




				def        a				(   self			):
											snake_case_     							=       ''
											snake_case_							,       snake_case_     							=       process_story(snake_case			)
											self.assertEqual(snake_case ,  []			)
											self.assertEqual(snake_case ,  []			)




				def        a				(   self			):
											snake_case_     							=       (
											    'It was the year of Our Lord one thousand seven hundred and '
											    'seventy-five\n\nSpiritual revelations were conceded to England '
											    'at that favoured period, as at this.\n@highlight\n\nIt was the best of times'
											)
											snake_case_							,       snake_case_     							=       process_story(snake_case			)

											snake_case_     							=       [
											    'It was the year of Our Lord one thousand seven hundred and seventy-five.',
											    'Spiritual revelations were conceded to England at that favoured period, as at this.',
											]
											self.assertEqual(snake_case ,  snake_case			)

											snake_case_     							=       ['It was the best of times.']
											self.assertEqual(snake_case ,  snake_case			)




				def        a				(   self			):
											snake_case_     							=       torch.tensor([1, 2, 3, 4]			)
											snake_case_     							=       torch.tensor([1, 1, 1, 1]			)
											np.testing.assert_array_equal(build_mask(snake_case ,  0			).numpy() ,  expected.numpy()			)




				def        a				(   self			):
											snake_case_     							=       torch.tensor([1, 2, 3, 4, 23, 23, 23]			)
											snake_case_     							=       torch.tensor([1, 1, 1, 1, 0, 0, 0]			)
											np.testing.assert_array_equal(build_mask(snake_case ,  23			).numpy() ,  expected.numpy()			)




				def        a				(   self			):
											snake_case_     							=       torch.tensor([8, 2, 3, 4, 1, 1, 1]			)
											snake_case_     							=       torch.tensor([1, 1, 1, 1, 0, 0, 0]			)
											np.testing.assert_array_equal(build_mask(snake_case ,  1			).numpy() ,  expected.numpy()			)




				def        a				(   self			):
											snake_case_     							=       101
											snake_case_     							=       torch.tensor([[1, 2, 3, 4, 5, 6], [1, 2, 3, 101, 5, 6], [1, 101, 3, 4, 101, 6]]			)
											snake_case_     							=       torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 0, 0, 0], [1, 0, 0, 0, 1, 1]]			)

											snake_case_     							=       compute_token_type_ids(snake_case ,  snake_case			)
											np.testing.assert_array_equal(snake_case ,  snake_case			)




