


'''simple docstring'''






import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
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 		a__    (							a__    ,    a__    ,    unittest.TestCase  ):





							'''simple docstring'''






							lowercase__      :       Any     						=				IFImgaImgSuperResolutionPipeline
							lowercase__      :       List[str]     						=				TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
							lowercase__      :       Optional[int]     						=				TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"}  )
							lowercase__      :       int     						=				PipelineTesterMixin.required_optional_params - {"latents"}







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														return self._get_superresolution_dummy_components()







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_=0       )	->							Tuple:
														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__	       =     floats_tensor((1, 3, 16, 16) ,   rng=random.Random(lowerCamelCase_       )       ).to(lowerCamelCase_       )

														lowerCAmelCase__	       =     {
														    '''prompt''': '''A painting of a squirrel eating a burger''',
														    '''image''': image,
														    '''original_image''': original_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   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Union[str, Any]:
														self._test_save_load_optional_components()







							@unittest.skipIf(torch_device != '''cuda''' ,   reason='''float16 requires CUDA'''       )
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														# 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   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														self._test_attention_slicing_forward_pass(expected_max_diff=1e-2       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														self._test_save_load_local()







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[Any]:
														self._test_inference_batch_single_identical(
														    expected_max_diff=1e-2 ,   )



'''simple docstring'''






from __future__ import annotations

import math
from collections.abc import Callable


def  _snake_case       (					A			,   A			,   A			,   A = 100			,   )						->   float:
							lowerCAmelCase__	       =     x_start
							lowerCAmelCase__	       =     fnc(A	)
							lowerCAmelCase__	       =     0.0

							for _ in range(A	):
														# Approximates curve as a sequence of linear lines and sums their length
														lowerCAmelCase__	       =     (x_end - x_start) / steps + xa
														lowerCAmelCase__	       =     fnc(A	)
														length += math.hypot(xa - xa			,   fxa - fxa	)

														# Increment step
														lowerCAmelCase__	       =     xa
														lowerCAmelCase__	       =     fxa

							return length


if __name__ == "__main__":


		def  _snake_case       (					A	)						->   List[Any]:
									return math.sin(10 * x	)

		print('''f(x) = sin(10 * x)''')
		print('''The length of the curve from x = -10 to x = 10 is:''')
		__UpperCAmelCase       =							10
		while i <= 100_000:
				print(f"""With {i} steps: {line_length(f, -10, 10, i)}""")
				i *= 10