



'''simple docstring'''

import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


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







				"""simple docstring"""



				__UpperCamelCase    :		Any	=	StableDiffusionXLImgaImgPipeline
				__UpperCamelCase    :		Optional[Any]	=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
				__UpperCamelCase    :		Tuple	=	PipelineTesterMixin.required_optional_params - {'latents'}
				__UpperCamelCase    :		str	=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
				__UpperCamelCase    :		int	=	IMAGE_TO_IMAGE_IMAGE_PARAMS
				__UpperCamelCase    :		Union[str, Any]	=	IMAGE_TO_IMAGE_IMAGE_PARAMS




				def 					_snake_case  (self		):
										torch.manual_seed(0		)
										__lowerCAmelCase							       =				UNetaDConditionModel(
										    block_out_channels=(32, 64)       ,			layers_per_block=2       ,			sample_size=32       ,			in_channels=4       ,			out_channels=4       ,			down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,			up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')       ,			attention_head_dim=(2, 4)       ,			use_linear_projection=__lowercase       ,			addition_embed_type='''text_time'''       ,			addition_time_embed_dim=8       ,			transformer_layers_per_block=(1, 2)       ,			projection_class_embeddings_input_dim=80       ,			cross_attention_dim=64       ,			)
										__lowerCAmelCase							       =				EulerDiscreteScheduler(
										    beta_start=0.0_0_0_8_5       ,			beta_end=0.0_1_2       ,			steps_offset=1       ,			beta_schedule='''scaled_linear'''       ,			timestep_spacing='''leading'''       ,			)
										torch.manual_seed(0		)
										__lowerCAmelCase							       =				AutoencoderKL(
										    block_out_channels=[32, 64]       ,			in_channels=3       ,			out_channels=3       ,			down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']       ,			up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']       ,			latent_channels=4       ,			sample_size=1_28       ,			)
										torch.manual_seed(0		)
										__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='''gelu'''       ,			projection_dim=32       ,			)
										__lowerCAmelCase							       =				CLIPTextModel(__lowercase		)
										__lowerCAmelCase							       =				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       ,			local_files_only=__lowercase		)

										__lowerCAmelCase							       =				CLIPTextModelWithProjection(__lowercase		)
										__lowerCAmelCase							       =				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       ,			local_files_only=__lowercase		)

										__lowerCAmelCase							       =				{
										    '''unet''': unet,
										    '''scheduler''': scheduler,
										    '''vae''': vae,
										    '''text_encoder''': text_encoder,
										    '''tokenizer''': tokenizer,
										    '''text_encoder_2''': text_encoder_a,
										    '''tokenizer_2''': tokenizer_a,
										    # "safety_checker": None,
										    # "feature_extractor": None,
										}
										return components




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase=0		):
										__lowerCAmelCase							       =				floats_tensor((1, 3, 32, 32)       ,			rng=random.Random(__lowercase		)		).to(__lowercase		)
										__lowerCAmelCase							       =				image / 2 + 0.5
										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''': image,
										    '''generator''': generator,
										    '''num_inference_steps''': 2,
										    '''guidance_scale''': 5.0,
										    '''output_type''': '''numpy''',
										    '''strength''': 0.7_5,
										}
										return inputs




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
										__lowerCAmelCase							       =				self.get_dummy_components()
										__lowerCAmelCase							       =				StableDiffusionXLImgaImgPipeline(**__lowercase		)
										__lowerCAmelCase							       =				sd_pipe.to(__lowercase		)
										sd_pipe.set_progress_bar_config(disable=__lowercase		)

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

										assert image.shape == (1, 32, 32, 3)

										__lowerCAmelCase							       =				np.array([0.4_6_5_6, 0.4_8_4_0, 0.4_4_3_9, 0.6_6_9_8, 0.5_5_7_4, 0.4_5_2_4, 0.5_7_9_9, 0.5_9_4_3, 0.5_1_6_5]		)

										assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2




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




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




				def 					_snake_case  (self		):
										pass




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.get_dummy_components()
										__lowerCAmelCase							       =				StableDiffusionXLImgaImgPipeline(**__lowercase		)
										__lowerCAmelCase							       =				sd_pipe.to(__lowercase		)
										__lowerCAmelCase							       =				sd_pipe.to(__lowercase		)
										sd_pipe.set_progress_bar_config(disable=__lowercase		)

										# forward without prompt embeds
										__lowerCAmelCase							       =				self.get_dummy_inputs(__lowercase		)
										__lowerCAmelCase							       =				3 * ['''this is a negative prompt''']
										__lowerCAmelCase							       =				negative_prompt
										__lowerCAmelCase							       =				3 * [inputs['''prompt''']]

										__lowerCAmelCase							       =				sd_pipe(**__lowercase		)
										__lowerCAmelCase							       =				output.images[0, -3:, -3:, -1]

										# forward with prompt embeds
										__lowerCAmelCase							       =				self.get_dummy_inputs(__lowercase		)
										__lowerCAmelCase							       =				3 * ['''this is a negative prompt''']
										__lowerCAmelCase							       =				3 * [inputs.pop('''prompt'''		)]

										(
										    (
										    __lowerCAmelCase					
										)       ,					(
										    __lowerCAmelCase					
										)       ,					(
										    __lowerCAmelCase					
										)       ,					(
										    __lowerCAmelCase					
										)       ,										
										)							       =				sd_pipe.encode_prompt(__lowercase       ,			negative_prompt=__lowercase		)

										__lowerCAmelCase							       =				sd_pipe(
										    **__lowercase       ,			prompt_embeds=__lowercase       ,			negative_prompt_embeds=__lowercase       ,			pooled_prompt_embeds=__lowercase       ,			negative_pooled_prompt_embeds=__lowercase       ,			)
										__lowerCAmelCase							       =				output.images[0, -3:, -3:, -1]

										# make sure that it's equal
										assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()		).max() < 1e-4


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







				"""simple docstring"""



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




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase="cpu"       ,			__lowercase=torch.floataa       ,			__lowercase=0		):
										__lowerCAmelCase							       =				torch.Generator(device=__lowercase		).manual_seed(__lowercase		)
										__lowerCAmelCase							       =				np.random.RandomState(__lowercase		).standard_normal((1, 4, 64, 64)		)
										__lowerCAmelCase							       =				torch.from_numpy(__lowercase		).to(device=__lowercase       ,			dtype=__lowercase		)
										__lowerCAmelCase							       =				{
										    '''prompt''': '''a photograph of an astronaut riding a horse''',
										    '''latents''': latents,
										    '''generator''': generator,
										    '''num_inference_steps''': 3,
										    '''guidance_scale''': 7.5,
										    '''output_type''': '''numpy''',
										}
										return inputs




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''		)
										pipe.to(__lowercase		)
										pipe.set_progress_bar_config(disable=__lowercase		)

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

										assert image.shape == (1, 5_12, 5_12, 3)
										__lowerCAmelCase							       =				np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6]		)
										assert np.abs(image_slice - expected_slice		).max() < 7e-3





'''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))

