




'''simple docstring'''




from __future__ import annotations

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
	'''simple docstring'''





	assert n > 1 and a > 0 and greatest_common_divisor(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       ) == 1
	((UpperCAmelCase__)							,			(UpperCAmelCase__)							,			(UpperCAmelCase__))										=    extended_gcd(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       )  # Implemented below
	UpperCAmelCase__										=    (b * s) % n
	return x

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
	'''simple docstring'''





	((UpperCAmelCase__)							,			(UpperCAmelCase__))										=    extended_euclid(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       )  # Implemented below
	if b < 0:
		UpperCAmelCase__										=    (b % n + n) % n
	return b

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
	'''simple docstring'''





	UpperCAmelCase__										=    invert_modulo(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       )
	UpperCAmelCase__										=    (b * s) % n
	return x

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
	'''simple docstring'''





	assert a >= 0 and b >= 0

	if b == 0:
		UpperCAmelCase__							,			UpperCAmelCase__							,			UpperCAmelCase__										=    a, 1, 0
	else:
		((UpperCAmelCase__)							,			(UpperCAmelCase__)							,			(UpperCAmelCase__))										=    extended_gcd(SCREAMING_SNAKE_CASE__       ,						a % b       )
		UpperCAmelCase__										=    q
		UpperCAmelCase__										=    p - q * (a // b)

	assert a % d == 0 and b % d == 0
	assert d == a * x + b * y

	return (d, x, y)

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
	'''simple docstring'''





	if b == 0:
		return (1, 0)
	((UpperCAmelCase__)							,			(UpperCAmelCase__))										=    extended_euclid(SCREAMING_SNAKE_CASE__       ,						a % b       )
	UpperCAmelCase__										=    a // b
	return (y, x - k * y)

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
	'''simple docstring'''





	if a < b:
		UpperCAmelCase__							,			UpperCAmelCase__										=    b, a

	while a % b != 0:
		UpperCAmelCase__							,			UpperCAmelCase__										=    b, a % b

	return b


if __name__ == "__main__":
				from doctest import testmod

				testmod(name='modular_division', verbose=True)
				testmod(name='modular_division2', verbose=True)
				testmod(name='invert_modulo', verbose=True)
				testmod(name='extended_gcd', verbose=True)
				testmod(name='extended_euclid', verbose=True)
				testmod(name='greatest_common_divisor', verbose=True)






'''simple docstring'''




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 						lowerCAmelCase_   ( lowerCamelCase_			,  lowerCamelCase_			,  unittest.TestCase   ):







  '''simple docstring'''







  lowerCAmelCase_				:					Any				     =						IFImgaImgPipeline
  lowerCAmelCase_				:					Dict				     =						TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
  lowerCAmelCase_				:					Union[str, Any]				     =						TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
  lowerCAmelCase_				:					Dict				     =						PipelineTesterMixin.required_optional_params - {"""latents"""}


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int] ):






   """simple docstring"""






   return self._get_dummy_components()


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Tuple						,		_UpperCAmelCase    :	Any						,		_UpperCAmelCase    :	Any=0 ):






   """simple docstring"""






   if str(_UpperCAmelCase ).startswith("""mps""" ):
    UpperCAmelCase__										=    torch.manual_seed(_UpperCAmelCase )
   else:
    UpperCAmelCase__										=    torch.Generator(device=_UpperCAmelCase ).manual_seed(_UpperCAmelCase )

   UpperCAmelCase__										=    floats_tensor((1, 3, 32, 32)						,		rng=random.Random(_UpperCAmelCase ) ).to(_UpperCAmelCase )

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

   return inputs


  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[Any] ):






   """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 							SCREAMING_SNAKE_CASE__			(						self    :	int ):






   """simple docstring"""






   self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3 )


  @unittest.skipIf(torch_device != """cuda"""						,		reason="""float16 requires CUDA""" )
  def 							SCREAMING_SNAKE_CASE__			(						self    :	int ):






   """simple docstring"""






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


  @unittest.skipIf(torch_device != """cuda"""						,		reason="""float16 requires CUDA""" )
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int] ):






   """simple docstring"""






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


  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str] ):






   """simple docstring"""






   self._test_attention_slicing_forward_pass(expected_max_diff=1E-2 )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	int ):






   """simple docstring"""






   self._test_save_load_local()



  def 							SCREAMING_SNAKE_CASE__			(						self    :	Any ):






   """simple docstring"""






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