import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







class __snake_case				(						lowerCamelCase_   ,		lowerCamelCase_   ,		lowerCamelCase_   ,		unittest.TestCase		):
   lowerCAmelCase_														=							AltDiffusionPipeline
   lowerCAmelCase_														=							TEXT_TO_IMAGE_PARAMS
   lowerCAmelCase_														=							TEXT_TO_IMAGE_BATCH_PARAMS
   lowerCAmelCase_														=							TEXT_TO_IMAGE_IMAGE_PARAMS
   lowerCAmelCase_														=							TEXT_TO_IMAGE_IMAGE_PARAMS




   def 	__a						(    self			:				List[str]      ):



     """simple docstring"""






     torch.manual_seed(0      )
     SCREAMING_SNAKE_CASE__										=      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""")       ,	cross_attention_dim=32       ,	)
     SCREAMING_SNAKE_CASE__										=      DDIMScheduler(
         beta_start=0.0_00_85       ,	beta_end=0.0_12       ,	beta_schedule="""scaled_linear"""       ,	clip_sample=_lowercase       ,	set_alpha_to_one=_lowercase       ,	)
     torch.manual_seed(0      )
     SCREAMING_SNAKE_CASE__										=      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       ,	)

     # TODO: address the non-deterministic text encoder (fails for save-load tests)
     # torch.manual_seed(0)
     # text_encoder_config = RobertaSeriesConfig(
     #     hidden_size=32,
     #     project_dim=32,
     #     intermediate_size=37,
     #     layer_norm_eps=1e-05,
     #     num_attention_heads=4,
     #     num_hidden_layers=5,
     #     vocab_size=5002,
     # )
     # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

     torch.manual_seed(0      )
     SCREAMING_SNAKE_CASE__										=      CLIPTextConfig(
         bos_token_id=0       ,	eos_token_id=2       ,	hidden_size=32       ,	projection_dim=32       ,	intermediate_size=37       ,	layer_norm_eps=1E-05       ,	num_attention_heads=4       ,	num_hidden_layers=5       ,	pad_token_id=1       ,	vocab_size=50_02       ,	)
     SCREAMING_SNAKE_CASE__										=      CLIPTextModel(_lowercase      )

     SCREAMING_SNAKE_CASE__										=      XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta"""      )
     SCREAMING_SNAKE_CASE__										=      77

     SCREAMING_SNAKE_CASE__										=      {
         """unet""": unet,
         """scheduler""": scheduler,
         """vae""": vae,
         """text_encoder""": text_encoder,
         """tokenizer""": tokenizer,
         """safety_checker""": None,
         """feature_extractor""": None,
     }
     return components




   def 	__a						(    self			:				Dict       ,	_lowercase			:				Tuple       ,	_lowercase			:				int=0      ):



     """simple docstring"""






     if str(_lowercase      ).startswith("""mps"""      ):
       SCREAMING_SNAKE_CASE__										=      torch.manual_seed(_lowercase      )
     else:
       SCREAMING_SNAKE_CASE__										=      torch.Generator(device=_lowercase      ).manual_seed(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      {
         """prompt""": """A painting of a squirrel eating a burger""",
         """generator""": generator,
         """num_inference_steps""": 2,
         """guidance_scale""": 6.0,
         """output_type""": """numpy""",
     }
     return inputs




   def 	__a						(    self			:				Any      ):



     """simple docstring"""






     super().test_attention_slicing_forward_pass(expected_max_diff=3E-3      )




   def 	__a						(    self			:				Tuple      ):



     """simple docstring"""






     super().test_inference_batch_single_identical(expected_max_diff=3E-3      )




   def 	__a						(    self			:				List[str]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      """cpu"""  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__										=      self.get_dummy_components()
     torch.manual_seed(0      )
     SCREAMING_SNAKE_CASE__										=      RobertaSeriesConfig(
         hidden_size=32       ,	project_dim=32       ,	intermediate_size=37       ,	layer_norm_eps=1E-05       ,	num_attention_heads=4       ,	num_hidden_layers=5       ,	vocab_size=50_02       ,	)
     # TODO: remove after fixing the non-deterministic text encoder
     SCREAMING_SNAKE_CASE__										=      RobertaSeriesModelWithTransformation(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      text_encoder

     SCREAMING_SNAKE_CASE__										=      AltDiffusionPipeline(**_lowercase      )
     SCREAMING_SNAKE_CASE__										=      alt_pipe.to(_lowercase      )
     alt_pipe.set_progress_bar_config(disable=_lowercase      )

     SCREAMING_SNAKE_CASE__										=      self.get_dummy_inputs(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      """A photo of an astronaut"""
     SCREAMING_SNAKE_CASE__										=      alt_pipe(**_lowercase      )
     SCREAMING_SNAKE_CASE__										=      output.images
     SCREAMING_SNAKE_CASE__										=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__										=      np.array(
         [0.5_74_81_62, 0.60_44_71_45, 0.48_82_12_17, 0.50_10_06_36, 0.5_43_11_85, 0.45_76_36_83, 0.49_65_76_96, 0.48_13_27_33, 0.47_57_30_93]      )

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




   def 	__a						(    self			:				Tuple      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      """cpu"""  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__										=      self.get_dummy_components()
     SCREAMING_SNAKE_CASE__										=      PNDMScheduler(skip_prk_steps=_lowercase      )
     torch.manual_seed(0      )
     SCREAMING_SNAKE_CASE__										=      RobertaSeriesConfig(
         hidden_size=32       ,	project_dim=32       ,	intermediate_size=37       ,	layer_norm_eps=1E-05       ,	num_attention_heads=4       ,	num_hidden_layers=5       ,	vocab_size=50_02       ,	)
     # TODO: remove after fixing the non-deterministic text encoder
     SCREAMING_SNAKE_CASE__										=      RobertaSeriesModelWithTransformation(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      text_encoder
     SCREAMING_SNAKE_CASE__										=      AltDiffusionPipeline(**_lowercase      )
     SCREAMING_SNAKE_CASE__										=      alt_pipe.to(_lowercase      )
     alt_pipe.set_progress_bar_config(disable=_lowercase      )

     SCREAMING_SNAKE_CASE__										=      self.get_dummy_inputs(_lowercase      )
     SCREAMING_SNAKE_CASE__										=      alt_pipe(**_lowercase      )
     SCREAMING_SNAKE_CASE__										=      output.images
     SCREAMING_SNAKE_CASE__										=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__										=      np.array(
         [0.51_60_50_93, 0.5_70_72_41, 0.47_36_55_07, 0.50_57_88_86, 0.5_63_38_77, 0.4_64_25_03, 0.5_18_20_81, 0.48_76_34_84, 0.49_08_42_37]      )

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







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




   def 	__a						(    self			:				Dict      ):



     """simple docstring"""






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




   def 	__a						(    self			:				Optional[Any]      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      AltDiffusionPipeline.from_pretrained("""BAAI/AltDiffusion"""       ,	safety_checker=_lowercase      )
     SCREAMING_SNAKE_CASE__										=      alt_pipe.to(_lowercase      )
     alt_pipe.set_progress_bar_config(disable=_lowercase      )

     SCREAMING_SNAKE_CASE__										=      """A painting of a squirrel eating a burger"""
     SCREAMING_SNAKE_CASE__										=      torch.manual_seed(0      )
     SCREAMING_SNAKE_CASE__										=      alt_pipe([prompt]       ,	generator=_lowercase       ,	guidance_scale=6.0       ,	num_inference_steps=20       ,	output_type="""np"""      )

     SCREAMING_SNAKE_CASE__										=      output.images

     SCREAMING_SNAKE_CASE__										=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 5_12, 5_12, 3)
     SCREAMING_SNAKE_CASE__										=      np.array([0.10_10, 0.08_00, 0.07_94, 0.08_85, 0.08_43, 0.07_62, 0.07_69, 0.07_29, 0.05_86]      )

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




   def 	__a						(    self			:				Any      ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__										=      DDIMScheduler.from_pretrained("""BAAI/AltDiffusion"""       ,	subfolder="""scheduler"""      )

     SCREAMING_SNAKE_CASE__										=      AltDiffusionPipeline.from_pretrained("""BAAI/AltDiffusion"""       ,	scheduler=_lowercase       ,	safety_checker=_lowercase      )
     SCREAMING_SNAKE_CASE__										=      alt_pipe.to(_lowercase      )
     alt_pipe.set_progress_bar_config(disable=_lowercase      )

     SCREAMING_SNAKE_CASE__										=      """A painting of a squirrel eating a burger"""
     SCREAMING_SNAKE_CASE__										=      torch.manual_seed(0      )

     SCREAMING_SNAKE_CASE__										=      alt_pipe([prompt]       ,	generator=_lowercase       ,	num_inference_steps=2       ,	output_type="""numpy"""      )
     SCREAMING_SNAKE_CASE__										=      output.images

     SCREAMING_SNAKE_CASE__										=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 5_12, 5_12, 3)
     SCREAMING_SNAKE_CASE__										=      np.array([0.40_19, 0.40_52, 0.38_10, 0.41_19, 0.39_16, 0.39_82, 0.46_51, 0.41_95, 0.53_23]      )

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

from datetime import datetime

import requests
from bsa import BeautifulSoup

if __name__ == "__main__":
   __lowerCamelCase			: str							   =		input('''Enter image url: ''').strip()
   print(F"""Downloading image from {url} ...""")
   __lowerCamelCase			: Any							   =		BeautifulSoup(requests.get(url).content, '''html.parser''')
   # The image URL is in the content field of the first meta tag with property og:image
   __lowerCamelCase			: List[Any]							   =		soup.find('''meta''', {'''property''': '''og:image'''})['''content''']
   __lowerCamelCase			: Tuple							   =		requests.get(image_url).content
   __lowerCamelCase			: Union[str, Any]							   =		F"""{datetime.now():%Y-%m-%d_%H:%M:%S}.jpg"""
   with open(file_name, '''wb''') as fp:
      fp.write(image_data)
   print(F"""Done. Image saved to disk as {file_name}.""")
