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

  A_    							=						StableDiffusionXLImgaImgPipeline
  A_    							=						TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
  A_    							=						PipelineTesterMixin.required_optional_params - {'''latents'''}
  A_    							=						TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
  A_    							=						IMAGE_TO_IMAGE_IMAGE_PARAMS
  A_    							=						IMAGE_TO_IMAGE_IMAGE_PARAMS




  def 		lowerCamelCase__  (		self      :       Optional[Any]      ):







    '''simple docstring'''


    torch.manual_seed(0      )
    lowercase_     =       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   ,				)
    lowercase_     =       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      )
    lowercase_     =       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=128   ,				)
    torch.manual_seed(0      )
    lowercase_     =       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=1_000   ,				hidden_act="""gelu"""   ,				projection_dim=32   ,				)
    lowercase_     =       CLIPTextModel(lowercase_      )
    lowercase_     =       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""   ,				local_files_only=lowercase_      )

    lowercase_     =       CLIPTextModelWithProjection(lowercase_      )
    lowercase_     =       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""   ,				local_files_only=lowercase_      )

    lowercase_     =       {
        """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 		lowerCamelCase__  (		self      :       List[Any]   ,				lowercase_      :       List[Any]   ,				lowercase_      :       Union[str, Any]=0      ):







    '''simple docstring'''


    lowercase_     =       floats_tensor((1, 3, 32, 32)   ,				rng=random.Random(lowercase_      )      ).to(lowercase_      )
    lowercase_     =       image / 2 + 0.5
    if str(lowercase_      ).startswith("""mps"""      ):
      lowercase_     =       torch.manual_seed(lowercase_      )
    else:
      lowercase_     =       torch.Generator(device=lowercase_      ).manual_seed(lowercase_      )
    lowercase_     =       {
        """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 		lowerCamelCase__  (		self      :       List[Any]      ):







    '''simple docstring'''


    lowercase_     =       """cpu"""  # ensure determinism for the device-dependent torch.Generator
    lowercase_     =       self.get_dummy_components()
    lowercase_     =       StableDiffusionXLImgaImgPipeline(**lowercase_      )
    lowercase_     =       sd_pipe.to(lowercase_      )
    sd_pipe.set_progress_bar_config(disable=lowercase_      )

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

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

    lowercase_     =       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 		lowerCamelCase__  (		self      :       Optional[Any]      ):







    '''simple docstring'''


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




  def 		lowerCamelCase__  (		self      :       List[Any]      ):







    '''simple docstring'''


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




  def 		lowerCamelCase__  (		self      :       int      ):







    '''simple docstring'''


    pass





  def 		lowerCamelCase__  (		self      :       Dict      ):







    '''simple docstring'''


    lowercase_     =       self.get_dummy_components()
    lowercase_     =       StableDiffusionXLImgaImgPipeline(**lowercase_      )
    lowercase_     =       sd_pipe.to(lowercase_      )
    lowercase_     =       sd_pipe.to(lowercase_      )
    sd_pipe.set_progress_bar_config(disable=lowercase_      )

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

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

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

    (
        (
        lowercase_
    )     ,	(
        lowercase_
    )     ,	(
        lowercase_
    )     ,	(
        lowercase_
    )     ,	
    )     =       sd_pipe.encode_prompt(lowercase_   ,				negative_prompt=lowercase_      )

    lowercase_     =       sd_pipe(
        **lowercase_   ,				prompt_embeds=lowercase_   ,				negative_prompt_embeds=lowercase_   ,				pooled_prompt_embeds=lowercase_   ,				negative_pooled_prompt_embeds=lowercase_   ,				)
    lowercase_     =       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 		lowerCamelCase__  (		self      :       int      ):







    '''simple docstring'''


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




  def 		lowerCamelCase__  (		self      :       Dict   ,				lowercase_      :       Tuple   ,				lowercase_      :       Dict="cpu"   ,				lowercase_      :       Union[str, Any]=torch.floataa   ,				lowercase_      :       int=0      ):







    '''simple docstring'''


    lowercase_     =       torch.Generator(device=lowercase_      ).manual_seed(lowercase_      )
    lowercase_     =       np.random.RandomState(lowercase_      ).standard_normal((1, 4, 64, 64)      )
    lowercase_     =       torch.from_numpy(lowercase_      ).to(device=lowercase_   ,				dtype=lowercase_      )
    lowercase_     =       {
        """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 		lowerCamelCase__  (		self      :       Union[str, Any]      ):







    '''simple docstring'''


    lowercase_     =       DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""      )
    pipe.to(lowercase_      )
    pipe.set_progress_bar_config(disable=lowercase_      )

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

    assert image.shape == (1, 512, 512, 3)
    lowercase_     =       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

__snake_case						  =		"""https://newsapi.org/v1/articles?source=bbc-news&sortBy=top&apiKey="""

def   A_      (       SCREAMING_SNAKE_CASE_						)			->None:
  # fetching a list of articles in json format
  lowercase_     =       requests.get(_NEWS_API + bbc_news_api_key						).json()
  # each article in the list is a dict
  for i, article in enumerate(bbc_news_page["""articles"""] ,	1						):
    print(f"""{i}.) {article["title"]}"""						)


if __name__ == "__main__":
       fetch_bbc_news(bbc_news_api_key="""<Your BBC News API key goes here>""")

