





'''simple docstring'''




import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






def 			_lowerCAmelCase     (    __snake_case    :					Union[str, Any]     )	->	Optional[int]:
     __A		:					str						=			[tensor.shape for tensor in tensor_list]
     return all(shape == shapes[0] for shape in shapes[1:]     )


class 					SCREAMING_SNAKE_CASE       (a__   ,						a__   ,						a__   ,						unittest.TestCase				):
     lowerCAmelCase						     =			StableDiffusionLatentUpscalePipeline
     lowerCAmelCase						     =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
         '''height''',
         '''width''',
         '''cross_attention_kwargs''',
         '''negative_prompt_embeds''',
         '''prompt_embeds''',
     }
     lowerCAmelCase						     =			PipelineTesterMixin.required_optional_params - {'''num_images_per_prompt'''}
     lowerCAmelCase						     =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     lowerCAmelCase						     =			frozenset(
         []				)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
     lowerCAmelCase						     =			frozenset([]				)

     lowerCAmelCase						     =			True


     @property
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[int]						=			1
          __A		:					str						=			4
          __A		:					Dict						=			(16, 16)

          __A		:					List[Any]						=			floats_tensor((batch_size, num_channels) + sizes		,      rng=random.Random(0)).to(_UpperCAmelCase)
          return image


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          torch.manual_seed(0)
          __A		:					Dict						=			UNetaDConditionModel(
              act_fn='gelu'		,      attention_head_dim=8		,      norm_num_groups=_UpperCAmelCase		,      block_out_channels=[32, 32, 64, 64]		,      time_cond_proj_dim=160		,      conv_in_kernel=1		,      conv_out_kernel=1		,      cross_attention_dim=32		,      down_block_types=(
                  'KDownBlock2D',
                  'KCrossAttnDownBlock2D',
                  'KCrossAttnDownBlock2D',
                  'KCrossAttnDownBlock2D',
              )		,      in_channels=8		,      mid_block_type=_UpperCAmelCase		,      only_cross_attention=_UpperCAmelCase		,      out_channels=5		,      resnet_time_scale_shift='scale_shift'		,      time_embedding_type='fourier'		,      timestep_post_act='gelu'		,      up_block_types=('KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KUpBlock2D')		,      )
          __A		:					int						=			AutoencoderKL(
              block_out_channels=[32, 32, 64, 64]		,      in_channels=3		,      out_channels=3		,      down_block_types=[
                  'DownEncoderBlock2D',
                  'DownEncoderBlock2D',
                  'DownEncoderBlock2D',
                  'DownEncoderBlock2D',
              ]		,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']		,      latent_channels=4		,      )
          __A		:					List[Any]						=			EulerDiscreteScheduler(prediction_type='sample')
          __A		:					Union[str, Any]						=			CLIPTextConfig(
              bos_token_id=0		,      eos_token_id=2		,      hidden_size=32		,      intermediate_size=37		,      layer_norm_eps=1e-0_5		,      num_attention_heads=4		,      num_hidden_layers=5		,      pad_token_id=1		,      vocab_size=1000		,      hidden_act='quick_gelu'		,      projection_dim=512		,      )
          __A		:					List[str]						=			CLIPTextModel(_UpperCAmelCase)
          __A		:					Union[str, Any]						=			CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

          __A		:					List[str]						=			{
              'unet': model.eval(),
              'vae': vae.eval(),
              'scheduler': scheduler,
              'text_encoder': text_encoder,
              'tokenizer': tokenizer,
          }

          return components


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase=0):

          '''simple docstring'''






          if str(_UpperCAmelCase).startswith('mps'):
               __A		:					Optional[Any]						=			torch.manual_seed(_UpperCAmelCase)
          else:
               __A		:					Tuple						=			torch.Generator(device=_UpperCAmelCase).manual_seed(_UpperCAmelCase)
          __A		:					List[str]						=			{
              'prompt': 'A painting of a squirrel eating a burger',
              'image': self.dummy_image.cpu(),
              'generator': generator,
              'num_inference_steps': 2,
              'output_type': 'numpy',
          }
          return inputs


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[Any]						=			'cpu'

          __A		:					str						=			self.get_dummy_components()
          __A		:					Optional[Any]						=			self.pipeline_class(**_UpperCAmelCase)
          pipe.to(_UpperCAmelCase)
          pipe.set_progress_bar_config(disable=_UpperCAmelCase)

          __A		:					Optional[Any]						=			self.get_dummy_inputs(_UpperCAmelCase)
          __A		:					List[str]						=			pipe(**_UpperCAmelCase).images
          __A		:					Union[str, Any]						=			image[0, -3:, -3:, -1]

          self.assertEqual(image.shape		,      (1, 256, 256, 3))
          __A		:					Any						=			np.array(
              [0.47222412, 0.41921633, 0.44717434, 0.46874192, 0.42588258, 0.46150726, 0.4677534, 0.45583832, 0.48579055])
          __A		:					List[Any]						=			np.abs(image_slice.flatten() - expected_slice).max()
          self.assertLessEqual(_UpperCAmelCase		,      1e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_attention_slicing_forward_pass(expected_max_diff=7e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_cpu_offload_forward_pass(expected_max_diff=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_inference_batch_single_identical(expected_max_diff=7e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_save_load_local(expected_max_difference=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_save_load_optional_components(expected_max_difference=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Tuple						=			[
              'DDIMScheduler',
              'DDPMScheduler',
              'PNDMScheduler',
              'HeunDiscreteScheduler',
              'EulerAncestralDiscreteScheduler',
              'KDPM2DiscreteScheduler',
              'KDPM2AncestralDiscreteScheduler',
              'DPMSolverSDEScheduler',
          ]
          __A		:					int						=			self.get_dummy_components()
          __A		:					Union[str, Any]						=			self.pipeline_class(**_UpperCAmelCase)

          # make sure that PNDM does not need warm-up
          pipe.scheduler.register_to_config(skip_prk_steps=_UpperCAmelCase)

          pipe.to(_UpperCAmelCase)
          pipe.set_progress_bar_config(disable=_UpperCAmelCase)
          __A		:					int						=			self.get_dummy_inputs(_UpperCAmelCase)
          __A		:					Union[str, Any]						=			2

          __A		:					List[str]						=			[]
          for scheduler_enum in KarrasDiffusionSchedulers:
               if scheduler_enum.name in skip_schedulers:
                    # no sigma schedulers are not supported
                    # no schedulers
                    continue

               __A		:					List[str]						=			getattr(_UpperCAmelCase		,      scheduler_enum.name)
               __A		:					Optional[Any]						=			scheduler_cls.from_config(pipe.scheduler.config)
               __A		:					Any						=			pipe(**_UpperCAmelCase)[0]
               outputs.append(_UpperCAmelCase)

          assert check_same_shape(_UpperCAmelCase)




@require_torch_gpu
@slow
class 					SCREAMING_SNAKE_CASE       (unittest.TestCase				):


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					str						=			torch.manual_seed(33)

          __A		:					List[str]						=			StableDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'		,      torch_dtype=torch.floataa)
          pipe.to('cuda')

          __A		:					List[Any]						=			StableDiffusionLatentUpscalePipeline.from_pretrained(
              'stabilityai/sd-x2-latent-upscaler'		,      torch_dtype=torch.floataa)
          upscaler.to('cuda')

          __A		:					Any						=			'a photo of an astronaut high resolution, unreal engine, ultra realistic'

          __A		:					Any						=			pipe(_UpperCAmelCase		,      generator=_UpperCAmelCase		,      output_type='latent').images

          __A		:					int						=			upscaler(
              prompt=_UpperCAmelCase		,      image=_UpperCAmelCase		,      num_inference_steps=20		,      guidance_scale=0		,      generator=_UpperCAmelCase		,      output_type='np'		,      ).images[0]

          __A		:					Optional[Any]						=			load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy')
          assert np.abs((expected_image - image).mean()) < 5e-2


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Union[str, Any]						=			torch.manual_seed(33)

          __A		:					Union[str, Any]						=			StableDiffusionLatentUpscalePipeline.from_pretrained(
              'stabilityai/sd-x2-latent-upscaler'		,      torch_dtype=torch.floataa)
          upscaler.to('cuda')

          __A		:					Any						=			'the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'

          __A		:					Dict						=			load_image(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png')

          __A		:					int						=			upscaler(
              prompt=_UpperCAmelCase		,      image=_UpperCAmelCase		,      num_inference_steps=20		,      guidance_scale=0		,      generator=_UpperCAmelCase		,      output_type='np'		,      ).images[0]

          __A		:					List[Any]						=			load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy')
          assert np.abs((expected_image - image).max()) < 5e-2





'''simple docstring'''
def 			lowerCamelCase(							SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_     )		->		tuple[float, float]:

			# Check if the input is valid
			if not len(SCREAMING_SNAKE_CASE_     ) == len(SCREAMING_SNAKE_CASE_     ) == 3:
						raise ValueError('Please enter a valid equation.'     )
			if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
						raise ValueError('Both a & b of two equations can\'t be zero.'     )

			# Extract the coefficients
			A_		, A_		, A_									= equationa
			A_		, A_		, A_									= equationa

			# Calculate the determinants of the matrices
			A_									= aa * ba - aa * ba
			A_									= ca * ba - ca * ba
			A_									= aa * ca - aa * ca

			# Check if the system of linear equations has a solution (using Cramer's rule)
			if determinant == 0:
						if determinant_x == determinant_y == 0:
									raise ValueError('Infinite solutions. (Consistent system)'     )
						else:
									raise ValueError('No solution. (Inconsistent system)'     )
			else:
						if determinant_x == determinant_y == 0:
									# Trivial solution (Inconsistent system)
									return (0.0, 0.0)
						else:
									A_									= determinant_x / determinant
									A_									= determinant_y / determinant
									# Non-Trivial Solution (Consistent system)
									return (x, y)




