





"""simple docstring"""


import gc
import unittest

import numpy as np
import torch

from diffusers import (
    AudioDiffusionPipeline,
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    DiffusionPipeline,
    Mel,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()



class      __SCREAMING_SNAKE_CASE    (						unittest.TestCase   ):







  '''simple docstring'''


  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				str:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()

  @property
  def    __SCREAMING_SNAKE_CASE				(		self   :       Dict	)		->				Tuple:
        torch.manual_seed(0	)
        _UpperCamelCase      :	Dict						=       UNetaDModel(
            sample_size=(32, 64)					,   in_channels=1					,   out_channels=1					,   layers_per_block=2					,   block_out_channels=(128, 128)					,   down_block_types=("AttnDownBlock2D", "DownBlock2D")					,   up_block_types=("UpBlock2D", "AttnUpBlock2D")					,   )
        return model

  @property
  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[Any]	)		->				List[str]:
        torch.manual_seed(0	)
        _UpperCamelCase      :	int						=       UNetaDConditionModel(
            sample_size=(64, 32)					,   in_channels=1					,   out_channels=1					,   layers_per_block=2					,   block_out_channels=(128, 128)					,   down_block_types=("CrossAttnDownBlock2D", "DownBlock2D")					,   up_block_types=("UpBlock2D", "CrossAttnUpBlock2D")					,   cross_attention_dim=10					,   )
        return model

  @property
  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]	)		->				Union[str, Any]:
        torch.manual_seed(0	)
        _UpperCamelCase      :	Any						=       AutoencoderKL(
            sample_size=(128, 64)					,   in_channels=1					,   out_channels=1					,   latent_channels=1					,   layers_per_block=2					,   block_out_channels=(128, 128)					,   down_block_types=("DownEncoderBlock2D", "DownEncoderBlock2D")					,   up_block_types=("UpDecoderBlock2D", "UpDecoderBlock2D")					,   )
        _UpperCamelCase      :	List[Any]						=       UNetaDModel(
            sample_size=(64, 32)					,   in_channels=1					,   out_channels=1					,   layers_per_block=2					,   block_out_channels=(128, 128)					,   down_block_types=("AttnDownBlock2D", "DownBlock2D")					,   up_block_types=("UpBlock2D", "AttnUpBlock2D")					,   )
        return vqvae, unet


  @slow
  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]	)		->				Tuple:
        _UpperCamelCase      :	List[str]						=       "cpu"  # ensure determinism for the device-dependent torch.Generator
        _UpperCamelCase      :	Union[str, Any]						=       Mel(
            x_res=self.dummy_unet.config.sample_size[1]					,   y_res=self.dummy_unet.config.sample_size[0]					,   )

        _UpperCamelCase      :	Union[str, Any]						=       DDPMScheduler()
        _UpperCamelCase      :	int						=       AudioDiffusionPipeline(vqvae=__a					,   unet=self.dummy_unet					,   mel=__a					,   scheduler=__a	)
        _UpperCamelCase      :	Optional[int]						=       pipe.to(__a	)
        pipe.set_progress_bar_config(disable=__a	)

        _UpperCamelCase      :	List[str]						=       torch.Generator(device=__a	).manual_seed(42	)
        _UpperCamelCase      :	List[str]						=       pipe(generator=__a					,   steps=4	)
        _UpperCamelCase      :	int						=       output.audios[0]
        _UpperCamelCase      :	Tuple						=       output.images[0]

        _UpperCamelCase      :	str						=       torch.Generator(device=__a	).manual_seed(42	)
        _UpperCamelCase      :	str						=       pipe(generator=__a					,   steps=4					,   return_dict=__a	)
        _UpperCamelCase      :	Optional[int]						=       output[0][0]

        assert audio.shape == (1, (self.dummy_unet.config.sample_size[1] - 1) * mel.hop_length)
        assert (
            image.height == self.dummy_unet.config.sample_size[0]
            and image.width == self.dummy_unet.config.sample_size[1]
        )
        _UpperCamelCase      :	Tuple						=       np.frombuffer(image.tobytes()					,   dtype="uint8"	)[:10]
        _UpperCamelCase      :	Union[str, Any]						=       np.frombuffer(image_from_tuple.tobytes()					,   dtype="uint8"	)[:10]
        _UpperCamelCase      :	List[Any]						=       np.array([69, 255, 255, 255, 0, 0, 77, 181, 12, 127]	)

        assert np.abs(image_slice.flatten() - expected_slice	).max() == 0
        assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() == 0

        _UpperCamelCase      :	Optional[Any]						=       Mel(
            x_res=self.dummy_vqvae_and_unet[0].config.sample_size[1]					,   y_res=self.dummy_vqvae_and_unet[0].config.sample_size[0]					,   )

        _UpperCamelCase      :	Tuple						=       DDIMScheduler()
        _UpperCamelCase      :	Any						=       self.dummy_vqvae_and_unet
        _UpperCamelCase      :	str						=       AudioDiffusionPipeline(
            vqvae=self.dummy_vqvae_and_unet[0]					,   unet=dummy_vqvae_and_unet[1]					,   mel=__a					,   scheduler=__a	)
        _UpperCamelCase      :	Union[str, Any]						=       pipe.to(__a	)
        pipe.set_progress_bar_config(disable=__a	)

        np.random.seed(0	)
        _UpperCamelCase      :	Optional[Any]						=       np.random.uniform(-1					,   1					,   ((dummy_vqvae_and_unet[0].config.sample_size[1] - 1) * mel.hop_length,)	)
        _UpperCamelCase      :	Dict						=       torch.Generator(device=__a	).manual_seed(42	)
        _UpperCamelCase      :	Dict						=       pipe(raw_audio=__a					,   generator=__a					,   start_step=5					,   steps=10	)
        _UpperCamelCase      :	Optional[int]						=       output.images[0]

        assert (
            image.height == self.dummy_vqvae_and_unet[0].config.sample_size[0]
            and image.width == self.dummy_vqvae_and_unet[0].config.sample_size[1]
        )
        _UpperCamelCase      :	int						=       np.frombuffer(image.tobytes()					,   dtype="uint8"	)[:10]
        _UpperCamelCase      :	int						=       np.array([120, 117, 110, 109, 138, 167, 138, 148, 132, 121]	)

        assert np.abs(image_slice.flatten() - expected_slice	).max() == 0

        _UpperCamelCase      :	int						=       self.dummy_unet_condition
        _UpperCamelCase      :	Optional[Any]						=       AudioDiffusionPipeline(
            vqvae=self.dummy_vqvae_and_unet[0]					,   unet=__a					,   mel=__a					,   scheduler=__a	)
        _UpperCamelCase      :	str						=       pipe.to(__a	)
        pipe.set_progress_bar_config(disable=__a	)

        np.random.seed(0	)
        _UpperCamelCase      :	Optional[int]						=       torch.rand((1, 1, 10)	)
        _UpperCamelCase      :	Any						=       pipe(generator=__a					,   encoding=__a	)
        _UpperCamelCase      :	int						=       output.images[0]
        _UpperCamelCase      :	str						=       np.frombuffer(image.tobytes()					,   dtype="uint8"	)[:10]
        _UpperCamelCase      :	Dict						=       np.array([107, 103, 120, 127, 142, 122, 113, 122, 97, 111]	)

        assert np.abs(image_slice.flatten() - expected_slice	).max() == 0





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







  '''simple docstring'''


  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[int]	)		->				Optional[int]:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()


  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				str:
        _UpperCamelCase      :	Any						=       torch_device

        _UpperCamelCase      :	Optional[Any]						=       DiffusionPipeline.from_pretrained("teticio/audio-diffusion-ddim-256"	)
        _UpperCamelCase      :	Any						=       pipe.to(__a	)
        pipe.set_progress_bar_config(disable=__a	)

        _UpperCamelCase      :	Any						=       torch.Generator(device=__a	).manual_seed(42	)
        _UpperCamelCase      :	List[str]						=       pipe(generator=__a	)
        _UpperCamelCase      :	Any						=       output.audios[0]
        _UpperCamelCase      :	Optional[int]						=       output.images[0]

        assert audio.shape == (1, (pipe.unet.config.sample_size[1] - 1) * pipe.mel.hop_length)
        assert image.height == pipe.unet.config.sample_size[0] and image.width == pipe.unet.config.sample_size[1]
        _UpperCamelCase      :	List[Any]						=       np.frombuffer(image.tobytes()					,   dtype="uint8"	)[:10]
        _UpperCamelCase      :	int						=       np.array([151, 167, 154, 144, 122, 134, 121, 105, 70, 26]	)

        assert np.abs(image_slice.flatten() - expected_slice	).max() == 0







"""simple docstring"""


from datetime import datetime

import requests
from bsa import BeautifulSoup

if __name__ == "__main__":
  lowerCamelCase__				  =   input("Enter image url: ").strip()
  print(f"""Downloading image from {url} ...""")
  lowerCamelCase__				  =   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__				  =   soup.find("meta", {"property": "og:image"})["content"]
  lowerCamelCase__				  =   requests.get(image_url).content
  lowerCamelCase__				  =   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}.""")
