


import random
import unittest

import torch

from diffusers import IFImgaImgPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin







@skip_mps
class 					__lowercase					(       a_ ,       a_ ,       unittest.TestCase     ):



		"""simple docstring"""

		UpperCamelCase    :				Tuple 					=		IFImgaImgPipeline
		UpperCamelCase    :				Dict 					=		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
		UpperCamelCase    :				Dict 					=		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
		UpperCamelCase    :				List[str] 					=		PipelineTesterMixin.required_optional_params - {"latents"}







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







					'''simple docstring'''







					return self._get_dummy_components()







		def 				__A      (   self		,			A		,			A=0  )     ->   int:







					'''simple docstring'''







					if str(A  ).startswith("""mps"""  ):
								lowerCamelCase								=     torch.manual_seed(A  )
					else:
								lowerCamelCase								=     torch.Generator(device=A  ).manual_seed(A  )

					lowerCamelCase								=     floats_tensor((1, 3, 32, 32)		,			rng=random.Random(A  )  ).to(A  )

					lowerCamelCase								=     {
					    """prompt""": """A painting of a squirrel eating a burger""",
					    """image""": image,
					    """generator""": generator,
					    """num_inference_steps""": 2,
					    """output_type""": """numpy""",
					}

					return inputs







		def 				__A      (   self  )     ->   Tuple:







					'''simple docstring'''







					self._test_save_load_optional_components()







		@unittest.skipIf(
		    torch_device != """cuda""" or not is_xformers_available()		,			reason="""XFormers attention is only available with CUDA and `xformers` installed"""		,			)
		def 				__A      (   self  )     ->   Union[str, Any]:







					'''simple docstring'''







					self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3  )







		@unittest.skipIf(torch_device != """cuda"""		,			reason="""float16 requires CUDA"""  )
		def 				__A      (   self  )     ->   Union[str, Any]:







					'''simple docstring'''







					super().test_save_load_floataa(expected_max_diff=1e-1  )







		@unittest.skipIf(torch_device != """cuda"""		,			reason="""float16 requires CUDA"""  )
		def 				__A      (   self  )     ->   Optional[Any]:







					'''simple docstring'''







					super().test_floataa_inference(expected_max_diff=1e-1  )







		def 				__A      (   self  )     ->   str:







					'''simple docstring'''







					self._test_attention_slicing_forward_pass(expected_max_diff=1e-2  )







		def 				__A      (   self  )     ->   str:







					'''simple docstring'''







					self._test_save_load_local()







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







					'''simple docstring'''







					self._test_inference_batch_single_identical(
					    expected_max_diff=1e-2		,			)





import unittest

from cer import CER


UpperCAmelCase      :						Union[str, Any]    =		CER()







class 					__lowercase					(       unittest.TestCase     ):



		"""simple docstring"""

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







					'''simple docstring'''







					lowerCamelCase								=     ["""White House"""]
					lowerCamelCase								=     ["""white house"""]
					# S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertTrue(abs(char_error_rate - 0.1818181818  ) < 1e-6  )







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







					'''simple docstring'''







					lowerCamelCase								=     ["""were wolf"""]
					lowerCamelCase								=     ["""werewolf"""]
					# S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertTrue(abs(char_error_rate - 0.1111111  ) < 1e-6  )

					lowerCamelCase								=     ["""werewolf"""]
					lowerCamelCase								=     ["""weae     wolf"""]
					# S = 1, D = 1, I = 0, N = 8, CER = 0.25
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertTrue(abs(char_error_rate - 0.25  ) < 1e-6  )

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

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







		def 				__A      (   self  )     ->   str:







					'''simple docstring'''







					lowerCamelCase								=     ["""werewolf"""]
					lowerCamelCase								=     ["""weaewolf"""]
					# S = 1, D = 0, I = 0, N = 8, CER = 0.125
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertTrue(abs(char_error_rate - 0.125  ) < 1e-6  )







		def 				__A      (   self  )     ->   Tuple:







					'''simple docstring'''







					lowerCamelCase								=     ["""werewolf"""]
					lowerCamelCase								=     ["""wereawolf"""]
					# S = 0, D = 1, I = 0, N = 8, CER = 0.125
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertTrue(abs(char_error_rate - 0.125  ) < 1e-6  )







		def 				__A      (   self  )     ->   List[Any]:







					'''simple docstring'''







					lowerCamelCase								=     ["""werewolf"""]
					lowerCamelCase								=     ["""wereolf"""]
					# S = 0, D = 0, I = 1, N = 8, CER = 0.125
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertTrue(abs(char_error_rate - 0.125  ) < 1e-6  )







		def 				__A      (   self  )     ->   Tuple:







					'''simple docstring'''







					lowerCamelCase								=     ["""werewolf"""]
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertEqual(A		,			0.0  )







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







					'''simple docstring'''







					lowerCamelCase								=     ["""werewolf""", """I am your father"""]
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertEqual(A		,			0.0  )

					lowerCamelCase								=     ["""werewolf""", """I am your father""", """doge"""]
					lowerCamelCase								=     ["""werxwolf""", """I       am your father""", """doge"""]
					# S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertTrue(abs(char_error_rate - 0.03571428  ) < 1e-6  )







		def 				__A      (   self  )     ->   List[Any]:







					'''simple docstring'''







					lowerCamelCase								=     ["""My hovercraft""", """is full of eels"""]
					lowerCamelCase								=     ["""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
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A		,			concatenate_texts=A  )
					self.assertTrue(abs(char_error_rate - 0.071428  ) < 1e-6  )







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







					'''simple docstring'''







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

					lowerCamelCase								=     ["""我能吞下玻璃""", """而不伤身体"""]
					lowerCamelCase								=     ["""我    能 吞 下 玻 璃""", """而不伤身体"""]
					# S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
					lowerCamelCase								=     cer.compute(predictions=A		,			references=A  )
					self.assertTrue(abs(char_error_rate - 0.454545454545  ) < 1e-6  )

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







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







					'''simple docstring'''







					lowerCamelCase								=     [""""""]
					lowerCamelCase								=     ["""Hypothesis"""]
					with self.assertRaises(A  ):
								cer.compute(predictions=A		,			references=A  )


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

