

import unittest

import numpy as np
import PIL
import torch

from diffusers.image_processor import VaeImageProcessor


class 					A		(				unittest.TestCase					):







    """simple docstring"""





    @property
    def 		snake_case__	( self					:			Any						)->       str:





        '''simple docstring'''







        A__        =  1
        A__        =  3
        A__        =  8
        A__        =  8

        A__        =  torch.rand((batch_size, num_channels, height, width)						)

        return sample


    def 		snake_case__	( self					:			Any,lowercase_					:			str						)->       Any:





        '''simple docstring'''







        if isinstance(image[0],PIL.Image.Image						):
            return np.stack([np.array(lowercase_						) for i in image],axis=0						)
        elif isinstance(lowercase_,torch.Tensor						):
            return image.cpu().numpy().transpose(0,2,3,1						)
        return image


    def 		snake_case__	( self					:			List[str]						)->       Dict:





        '''simple docstring'''







        A__        =  VaeImageProcessor(do_resize=lowercase_,do_normalize=lowercase_						)

        A__        =  self.dummy_sample
        A__        =  self.to_np(lowercase_						)

        for output_type in ["pt", "np", "pil"]:
            A__        =  image_processor.postprocess(
                image_processor.preprocess(lowercase_						),output_type=lowercase_,)
            A__        =  self.to_np(lowercase_						)
            A__        =  (input_np * 2_5_5).round() if output_type == 'pil' else input_np
            assert (
                np.abs(in_np - out_np						).max() < 1E-6
            ), F'decoded output does not match input for output_type {output_type}'


    def 		snake_case__	( self					:			Dict						)->       Optional[Any]:





        '''simple docstring'''







        A__        =  VaeImageProcessor(do_resize=lowercase_,do_normalize=lowercase_						)
        A__        =  self.dummy_sample.cpu().numpy().transpose(0,2,3,1						)

        for output_type in ["pt", "np", "pil"]:
            A__        =  image_processor.postprocess(image_processor.preprocess(lowercase_						),output_type=lowercase_						)

            A__        =  self.to_np(lowercase_						)
            A__        =  (input_np * 2_5_5).round() if output_type == 'pil' else input_np
            assert (
                np.abs(in_np - out_np						).max() < 1E-6
            ), F'decoded output does not match input for output_type {output_type}'


    def 		snake_case__	( self					:			List[str]						)->       str:





        '''simple docstring'''







        A__        =  VaeImageProcessor(do_resize=lowercase_,do_normalize=lowercase_						)

        A__        =  self.dummy_sample.cpu().numpy().transpose(0,2,3,1						)
        A__        =  image_processor.numpy_to_pil(lowercase_						)

        for output_type in ["pt", "np", "pil"]:
            A__        =  image_processor.postprocess(image_processor.preprocess(lowercase_						),output_type=lowercase_						)
            for i, o in zip(lowercase_,lowercase_						):
                A__        =  np.array(lowercase_						)
                A__        =  self.to_np(lowercase_						) if output_type == 'pil' else (self.to_np(lowercase_						) * 2_5_5).round()
                assert (
                    np.abs(in_np - out_np						).max() < 1E-6
                ), F'decoded output does not match input for output_type {output_type}'


    def 		snake_case__	( self					:			Union[str, Any]						)->       Tuple:





        '''simple docstring'''







        A__        =  VaeImageProcessor(do_resize=lowercase_,do_normalize=lowercase_						)

        A__        =  self.dummy_sample
        A__        =  input_pt_ad.squeeze(0						)

        A__        =  image_processor.postprocess(
            image_processor.preprocess(lowercase_						),output_type='np',)
        A__        =  image_processor.postprocess(
            image_processor.preprocess(lowercase_						),output_type='np',)

        A__        =  self.to_np(self.dummy_sample						)
        A__        =  input_np_ad.squeeze(0						)

        A__        =  image_processor.postprocess(
            image_processor.preprocess(lowercase_						),output_type='np',)
        A__        =  image_processor.postprocess(
            image_processor.preprocess(lowercase_						),output_type='np',)

        assert np.abs(out_pt_ad - out_pt_ad						).max() < 1E-6
        assert np.abs(out_np_ad - out_np_ad						).max() < 1E-6


    def 		snake_case__	( self					:			List[Any]						)->       Union[str, Any]:





        '''simple docstring'''







        A__        =  VaeImageProcessor(do_resize=lowercase_,do_normalize=lowercase_						)

        A__        =  self.dummy_sample
        A__        =  list(lowercase_						)

        A__        =  image_processor.postprocess(
            image_processor.preprocess(lowercase_						),output_type='np',)

        A__        =  image_processor.postprocess(
            image_processor.preprocess(lowercase_						),output_type='np',)

        A__        =  self.to_np(self.dummy_sample						)
        list(lowercase_						)

        A__        =  image_processor.postprocess(
            image_processor.preprocess(lowercase_						),output_type='np',)

        A__        =  image_processor.postprocess(
            image_processor.preprocess(lowercase_						),output_type='np',)

        assert np.abs(out_pt_ad - out_pt_list						).max() < 1E-6
        assert np.abs(out_np_ad - out_np_list						).max() < 1E-6




import unittest

from cer import CER


lowercase_									=    CER()


class 					A		(				unittest.TestCase					):







    """simple docstring"""





    def 		snake_case__	( self					:			str						)->       Dict:





        '''simple docstring'''







        A__        =  ['White House']
        A__        =  ['white house']
        # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.1_818_181_818						) < 1E-6						)


    def 		snake_case__	( self					:			str						)->       Dict:





        '''simple docstring'''







        A__        =  ['were wolf']
        A__        =  ['werewolf']
        # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.1_111_111						) < 1E-6						)

        A__        =  ['werewolf']
        A__        =  ['weae     wolf']
        # S = 1, D = 1, I = 0, N = 8, CER = 0.25
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.25						) < 1E-6						)

        # consecutive whitespaces case 1
        A__        =  ['were wolf']
        A__        =  ['were               wolf']
        # S = 0, D = 0, I = 0, N = 9, CER = 0
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.0						) < 1E-6						)

        # consecutive whitespaces case 2
        A__        =  ['were   wolf']
        A__        =  ['were               wolf']
        # S = 0, D = 0, I = 0, N = 9, CER = 0
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.0						) < 1E-6						)


    def 		snake_case__	( self					:			int						)->       str:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  ['weaewolf']
        # S = 1, D = 0, I = 0, N = 8, CER = 0.125
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.125						) < 1E-6						)


    def 		snake_case__	( self					:			Optional[int]						)->       Optional[int]:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  ['wereawolf']
        # S = 0, D = 1, I = 0, N = 8, CER = 0.125
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.125						) < 1E-6						)


    def 		snake_case__	( self					:			List[Any]						)->       Optional[Any]:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  ['wereolf']
        # S = 0, D = 0, I = 1, N = 8, CER = 0.125
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.125						) < 1E-6						)


    def 		snake_case__	( self					:			str						)->       Tuple:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertEqual(lowercase_,0.0						)


    def 		snake_case__	( self					:			Optional[int]						)->       Union[str, Any]:





        '''simple docstring'''







        A__        =  ['werewolf', 'I am your father']
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertEqual(lowercase_,0.0						)

        A__        =  ['werewolf', 'I am your father', 'doge']
        A__        =  ['werxwolf', 'I       am your father', 'doge']
        # S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.03_571_428						) < 1E-6						)


    def 		snake_case__	( self					:			List[str]						)->       Union[str, Any]:





        '''simple docstring'''







        A__        =  ['My hovercraft', 'is full of eels']
        A__        =  ['My hovercraft is full', ' of eels']
        # S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
        # whitespace at the front of " of eels" will be strip during preporcessing
        # so need to insert 2 whitespaces
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_,concatenate_texts=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.071_428						) < 1E-6						)


    def 		snake_case__	( self					:			Dict						)->       List[str]:





        '''simple docstring'''







        A__        =  ['我能吞下玻璃而不伤身体']
        A__        =  [' 能吞虾玻璃而 不霜身体啦']
        # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.4_545_454_545						) < 1E-6						)

        A__        =  ['我能吞下玻璃', '而不伤身体']
        A__        =  ['我    能 吞 下 玻 璃', '而不伤身体']
        # S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.454_545_454_545						) < 1E-6						)

        A__        =  ['我能吞下玻璃而不伤身体']
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertFalse(lowercase_,0.0						)


    def 		snake_case__	( self					:			Any						)->       List[str]:





        '''simple docstring'''







        A__        =  ['']
        A__        =  ['Hypothesis']
        with self.assertRaises(lowercase_						):
            cer.compute(predictions=lowercase_,references=lowercase_						)


if __name__ == "__main__":
     unittest.main()

