"""simple docstring"""


import warnings
from collections.abc import Callable
from typing import Any

import numpy
from matplotlib import pyplot

a							=0.25 + 0.0j
a							=-0.4 + 0.6j
a							=-0.1 + 0.6_51j
a							=-2.0
a							=56
a							=2.0
a							=666





def       lowerCamelCase_			( __lowerCAmelCase       ,   __lowerCAmelCase    )							-> numpy.ndarray:




						'''simple docstring'''



						return numpy.exp(__lowerCAmelCase    ) + c_parameter





def       lowerCamelCase_			( __lowerCAmelCase       ,   __lowerCAmelCase    )							-> numpy.ndarray:




						'''simple docstring'''



						return z_values * z_values + c_parameter





def       lowerCamelCase_			( __lowerCAmelCase       ,   __lowerCAmelCase    )							-> numpy.ndarray:




						'''simple docstring'''



						lowerCamelCase__ =numpy.linspace(-window_size       ,   __lowerCAmelCase       ,   __lowerCAmelCase    )
						lowerCamelCase__ =x.reshape((nb_pixels, 1)    )
						lowerCamelCase__ =numpy.linspace(-window_size       ,   __lowerCAmelCase       ,   __lowerCAmelCase    )
						lowerCamelCase__ =y.reshape((1, nb_pixels)    )
						return x + 1.0J * y





def       lowerCamelCase_			( __lowerCAmelCase       ,   __lowerCAmelCase       ,   __lowerCAmelCase       ,   __lowerCAmelCase       ,   __lowerCAmelCase = None       ,   )							-> numpy.ndarray:




						'''simple docstring'''



						lowerCamelCase__ =z_a.astype("complex64"    )
						for _ in range(__lowerCAmelCase    ):
												lowerCamelCase__ =eval_function(__lowerCAmelCase       ,   __lowerCAmelCase    )
												if infinity is not None:
																		numpy.nan_to_num(__lowerCAmelCase       ,   copy=__lowerCAmelCase       ,   nan=__lowerCAmelCase    )
																		lowerCamelCase__ =infinity
						return z_n





def       lowerCamelCase_			( __lowerCAmelCase       ,   __lowerCAmelCase       ,   __lowerCAmelCase       ,   __lowerCAmelCase       ,   )							-> None:




						'''simple docstring'''



						lowerCamelCase__ =(abs(__lowerCAmelCase    )).transpose()
						lowerCamelCase__ =abs_z_final[::-1, :]
						pyplot.matshow(abs_z_final < escape_radius    )
						pyplot.title(F'''Julia set of ${function_label}$, $c={function_params}$'''    )
						pyplot.show()





def       lowerCamelCase_			( )							-> None:




						'''simple docstring'''



						warnings.filterwarnings(
						    "ignore"       ,   category=__lowerCAmelCase       ,   message="overflow encountered in multiply"    )
						warnings.filterwarnings(
						    "ignore"       ,   category=__lowerCAmelCase       ,   message="invalid value encountered in multiply"       ,   )
						warnings.filterwarnings(
						    "ignore"       ,   category=__lowerCAmelCase       ,   message="overflow encountered in absolute"    )
						warnings.filterwarnings(
						    "ignore"       ,   category=__lowerCAmelCase       ,   message="overflow encountered in exp"    )


if __name__ == "__main__":
	a							=prepare_grid(window_size, nb_pixels)

	ignore_overflow_warnings()  # See file header for explanations

	a							=24
	a							=2 * abs(c_cauliflower) + 1
	a							=iterate_function(
	    eval_quadratic_polynomial,
	    c_cauliflower,
	    nb_iterations,
	    z_a,
	    infinity=1.1 * escape_radius,
	)
	show_results('z^2+c', c_cauliflower, escape_radius, z_final)

	a							=64
	a							=2 * abs(c_polynomial_a) + 1
	a							=iterate_function(
	    eval_quadratic_polynomial,
	    c_polynomial_a,
	    nb_iterations,
	    z_a,
	    infinity=1.1 * escape_radius,
	)
	show_results('z^2+c', c_polynomial_a, escape_radius, z_final)

	a							=161
	a							=2 * abs(c_polynomial_a) + 1
	a							=iterate_function(
	    eval_quadratic_polynomial,
	    c_polynomial_a,
	    nb_iterations,
	    z_a,
	    infinity=1.1 * escape_radius,
	)
	show_results('z^2+c', c_polynomial_a, escape_radius, z_final)

	a							=12
	a							=10_000.0
	a							=iterate_function(
	    eval_exponential,
	    c_exponential,
	    nb_iterations,
	    z_a + 2,
	    infinity=1.0E1_0,
	)
	show_results('e^z+c', c_exponential, escape_radius, z_final)



"""simple docstring"""


import random
import unittest

import torch

from diffusers import IFSuperResolutionPipeline
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        __UpperCAmelCase						(     __lowerCAmelCase				,				__lowerCAmelCase				,				unittest.TestCase     ):
				A__				:       Any  							=	IFSuperResolutionPipeline
				A__				:       Tuple  							=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
				A__				:       Optional[int]  							=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
				A__				:       List[Any]  							=	PipelineTesterMixin.required_optional_params - {'''latents'''}

				def 		_a     (				self				):
										return self._get_superresolution_dummy_components()

				def 		_a     (				self     ,			_lowerCamelCase     ,			_lowerCamelCase=0				):
										if str(_lowerCamelCase				).startswith("mps"				):
																lowerCamelCase__ =torch.manual_seed(_lowerCamelCase				)
										else:
																lowerCamelCase__ =torch.Generator(device=_lowerCamelCase				).manual_seed(_lowerCamelCase				)

										lowerCamelCase__ =floats_tensor((1, 3, 32, 32)     ,			rng=random.Random(_lowerCamelCase				)				).to(_lowerCamelCase				)

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

										return inputs

				@unittest.skipIf(
				    torch_device != "cuda" or not is_xformers_available()     ,			reason="XFormers attention is only available with CUDA and `xformers` installed"     ,			)
				def 		_a     (				self				):
										self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3				)

				def 		_a     (				self				):
										self._test_save_load_optional_components()

				@unittest.skipIf(torch_device != "cuda"     ,			reason="float16 requires CUDA"				)
				def 		_a     (				self				):
										# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
										super().test_save_load_floataa(expected_max_diff=1E-1				)

				def 		_a     (				self				):
										self._test_attention_slicing_forward_pass(expected_max_diff=1E-2				)

				def 		_a     (				self				):
										self._test_save_load_local()






				def 		_a     (				self				):
										self._test_inference_batch_single_identical(
										    expected_max_diff=1E-2     ,			)


