


'''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 							__magic_name__(						lowerCamelCase):
						__lowerCAmelCase							       =				[tensor.shape for tensor in tensor_list]
						return all(shape == shapes[0] for shape in shapes[1:])


class       a__				( __A							,						__A							,						__A							,						unittest.TestCase      ):







				"""simple docstring"""



				__UpperCamelCase    :		Optional[Any]	=	StableDiffusionLatentUpscalePipeline
				__UpperCamelCase    :		Dict	=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
				    'height',
				    'width',
				    'cross_attention_kwargs',
				    'negative_prompt_embeds',
				    'prompt_embeds',
				}
				__UpperCamelCase    :		str	=	PipelineTesterMixin.required_optional_params - {'num_images_per_prompt'}
				__UpperCamelCase    :		Tuple	=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
				__UpperCamelCase    :		List[Any]	=	frozenset(
				    []      )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
				__UpperCamelCase    :		Tuple	=	frozenset([]      )

				__UpperCamelCase    :		str	=	True




				@property
				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				1
										__lowerCAmelCase							       =				4
										__lowerCAmelCase							       =				(16, 16)

										__lowerCAmelCase							       =				floats_tensor((batch_size, num_channels) + sizes       ,			rng=random.Random(0		)		).to(__lowercase		)
										return image




				def 					_snake_case  (self		):
										torch.manual_seed(0		)
										__lowerCAmelCase							       =				UNetaDConditionModel(
										    act_fn='''gelu'''       ,			attention_head_dim=8       ,			norm_num_groups=__lowercase       ,			block_out_channels=[32, 32, 64, 64]       ,			time_cond_proj_dim=1_60       ,			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=__lowercase       ,			only_cross_attention=__lowercase       ,			out_channels=5       ,			resnet_time_scale_shift='''scale_shift'''       ,			time_embedding_type='''fourier'''       ,			timestep_post_act='''gelu'''       ,			up_block_types=('''KCrossAttnUpBlock2D''', '''KCrossAttnUpBlock2D''', '''KCrossAttnUpBlock2D''', '''KUpBlock2D''')       ,			)
										__lowerCAmelCase							       =				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       ,			)
										__lowerCAmelCase							       =				EulerDiscreteScheduler(prediction_type='''sample'''		)
										__lowerCAmelCase							       =				CLIPTextConfig(
										    bos_token_id=0       ,			eos_token_id=2       ,			hidden_size=32       ,			intermediate_size=37       ,			layer_norm_eps=1e-05       ,			num_attention_heads=4       ,			num_hidden_layers=5       ,			pad_token_id=1       ,			vocab_size=10_00       ,			hidden_act='''quick_gelu'''       ,			projection_dim=5_12       ,			)
										__lowerCAmelCase							       =				CLIPTextModel(__lowercase		)
										__lowerCAmelCase							       =				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

										__lowerCAmelCase							       =				{
										    '''unet''': model.eval(),
										    '''vae''': vae.eval(),
										    '''scheduler''': scheduler,
										    '''text_encoder''': text_encoder,
										    '''tokenizer''': tokenizer,
										}

										return components




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase=0		):
										if str(__lowercase		).startswith('''mps'''		):
																__lowerCAmelCase							       =				torch.manual_seed(__lowercase		)
										else:
																__lowerCAmelCase							       =				torch.Generator(device=__lowercase		).manual_seed(__lowercase		)
										__lowerCAmelCase							       =				{
										    '''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 					_snake_case  (self		):
										__lowerCAmelCase							       =				'''cpu'''

										__lowerCAmelCase							       =				self.get_dummy_components()
										__lowerCAmelCase							       =				self.pipeline_class(**__lowercase		)
										pipe.to(__lowercase		)
										pipe.set_progress_bar_config(disable=__lowercase		)

										__lowerCAmelCase							       =				self.get_dummy_inputs(__lowercase		)
										__lowerCAmelCase							       =				pipe(**__lowercase		).images
										__lowerCAmelCase							       =				image[0, -3:, -3:, -1]

										self.assertEqual(image.shape       ,			(1, 2_56, 2_56, 3)		)
										__lowerCAmelCase							       =				np.array(
										    [0.4_7_2_2_2_4_1_2, 0.4_1_9_2_1_6_3_3, 0.4_4_7_1_7_4_3_4, 0.4_6_8_7_4_1_9_2, 0.4_2_5_8_8_2_5_8, 0.4_6_1_5_0_7_2_6, 0.4_6_7_7_5_3_4, 0.4_5_5_8_3_8_3_2, 0.4_8_5_7_9_0_5_5]		)
										__lowerCAmelCase							       =				np.abs(image_slice.flatten() - expected_slice		).max()
										self.assertLessEqual(__lowercase       ,			1e-3		)




				def 					_snake_case  (self		):
										super().test_attention_slicing_forward_pass(expected_max_diff=7e-3		)




				def 					_snake_case  (self		):
										super().test_cpu_offload_forward_pass(expected_max_diff=3e-3		)




				def 					_snake_case  (self		):
										super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3		)




				def 					_snake_case  (self		):
										super().test_inference_batch_single_identical(expected_max_diff=7e-3		)




				def 					_snake_case  (self		):
										super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3e-3		)




				def 					_snake_case  (self		):
										super().test_save_load_local(expected_max_difference=3e-3		)




				def 					_snake_case  (self		):
										super().test_save_load_optional_components(expected_max_difference=3e-3		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				[
										    '''DDIMScheduler''',
										    '''DDPMScheduler''',
										    '''PNDMScheduler''',
										    '''HeunDiscreteScheduler''',
										    '''EulerAncestralDiscreteScheduler''',
										    '''KDPM2DiscreteScheduler''',
										    '''KDPM2AncestralDiscreteScheduler''',
										    '''DPMSolverSDEScheduler''',
										]
										__lowerCAmelCase							       =				self.get_dummy_components()
										__lowerCAmelCase							       =				self.pipeline_class(**__lowercase		)

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

										pipe.to(__lowercase		)
										pipe.set_progress_bar_config(disable=__lowercase		)
										__lowerCAmelCase							       =				self.get_dummy_inputs(__lowercase		)
										__lowerCAmelCase							       =				2

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

																__lowerCAmelCase							       =				getattr(__lowercase       ,			scheduler_enum.name		)
																__lowerCAmelCase							       =				scheduler_cls.from_config(pipe.scheduler.config		)
																__lowerCAmelCase							       =				pipe(**__lowercase		)[0]
																outputs.append(__lowercase		)

										assert check_same_shape(__lowercase		)


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







				"""simple docstring"""



				def 					_snake_case  (self		):
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				torch.manual_seed(33		)

										__lowerCAmelCase							       =				StableDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''       ,			torch_dtype=torch.floataa		)
										pipe.to('''cuda'''		)

										__lowerCAmelCase							       =				StableDiffusionLatentUpscalePipeline.from_pretrained(
										    '''stabilityai/sd-x2-latent-upscaler'''       ,			torch_dtype=torch.floataa		)
										upscaler.to('''cuda'''		)

										__lowerCAmelCase							       =				'''a photo of an astronaut high resolution, unreal engine, ultra realistic'''

										__lowerCAmelCase							       =				pipe(__lowercase       ,			generator=__lowercase       ,			output_type='''latent'''		).images

										__lowerCAmelCase							       =				upscaler(
										    prompt=__lowercase       ,			image=__lowercase       ,			num_inference_steps=20       ,			guidance_scale=0       ,			generator=__lowercase       ,			output_type='''np'''       ,			).images[0]

										__lowerCAmelCase							       =				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 					_snake_case  (self		):
										__lowerCAmelCase							       =				torch.manual_seed(33		)

										__lowerCAmelCase							       =				StableDiffusionLatentUpscalePipeline.from_pretrained(
										    '''stabilityai/sd-x2-latent-upscaler'''       ,			torch_dtype=torch.floataa		)
										upscaler.to('''cuda'''		)

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

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

										__lowerCAmelCase							       =				upscaler(
										    prompt=__lowercase       ,			image=__lowercase       ,			num_inference_steps=20       ,			guidance_scale=0       ,			generator=__lowercase       ,			output_type='''np'''       ,			).images[0]

										__lowerCAmelCase							       =				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'''

import requests
from bsa import BeautifulSoup

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase):
						__lowerCAmelCase							       =				BeautifulSoup(requests.get(lowerCamelCase,				params=lowerCamelCase).content,				'''html.parser''')
						__lowerCAmelCase							       =				soup.find('''div''',				attrs={'''class''': '''gs_ri'''})
						__lowerCAmelCase							       =				div.find('''div''',				attrs={'''class''': '''gs_fl'''}).find_all('''a''')
						return anchors[2].get_text()


if __name__ == "__main__":
	_UpperCAmelCase				: Union[str, Any]							    =				{
	    """title""": (
	        """Precisely geometry controlled microsupercapacitors for ultrahigh areal """
	        """capacitance, volumetric capacitance, and energy density"""
	    ),
	    """journal""": """Chem. Mater.""",
	    """volume""": 3_0,
	    """pages""": """3979-3990""",
	    """year""": 2_0_1_8,
	    """hl""": """en""",
	}
	print(get_citation("""https://scholar.google.com/scholar_lookup""", params=params))

