





"""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 		__snake_case					(		SCREAMING_SNAKE_CASE__							,							SCREAMING_SNAKE_CASE__							,							unittest.TestCase     ):





 """simple docstring"""


 _lowerCamelCase        =     StableDiffusionXLImgaImgPipeline
 _lowerCamelCase        =     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
 _lowerCamelCase        =     PipelineTesterMixin.required_optional_params - {"""latents"""}
 _lowerCamelCase        =     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 _lowerCamelCase        =     IMAGE_TO_IMAGE_IMAGE_PARAMS
 _lowerCamelCase        =     IMAGE_TO_IMAGE_IMAGE_PARAMS

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     torch.manual_seed(0  )
     __A    :						int						 =     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=__lowerCamelCase					,						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					,						)
     __A    :						Tuple						 =     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  )
     __A    :						Optional[Any]						 =     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  )
     __A    :						int						 =     CLIPTextConfig(
         bos_token_id=0					,						eos_token_id=2					,						hidden_size=32					,						intermediate_size=37					,						layer_norm_eps=1e-0_5					,						num_attention_heads=4					,						num_hidden_layers=5					,						pad_token_id=1					,						vocab_size=1000					,						hidden_act='''gelu'''					,						projection_dim=32					,						)
     __A    :						Optional[Any]						 =     CLIPTextModel(__lowerCamelCase  )
     __A    :						List[Any]						 =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					,						local_files_only=__lowerCamelCase  )

     __A    :						Optional[Any]						 =     CLIPTextModelWithProjection(__lowerCamelCase  )
     __A    :						str						 =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					,						local_files_only=__lowerCamelCase  )

     __A    :						Any						 =     {
         '''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 					UpperCamelCase__(    self					,						__lowerCamelCase					,						__lowerCamelCase=0  ):



     '''simple docstring'''




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



     '''simple docstring'''




     __A    :						List[Any]						 =     '''cpu'''  # ensure determinism for the device-dependent torch.Generator
     __A    :						List[str]						 =     self.get_dummy_components()
     __A    :						Dict						 =     StableDiffusionXLImgaImgPipeline(**__lowerCamelCase  )
     __A    :						Union[str, Any]						 =     sd_pipe.to(__lowerCamelCase  )
     sd_pipe.set_progress_bar_config(disable=__lowerCamelCase  )

     __A    :						Optional[Any]						 =     self.get_dummy_inputs(__lowerCamelCase  )
     __A    :						Dict						 =     sd_pipe(**__lowerCamelCase  ).images
     __A    :						Optional[int]						 =     image[0, -3:, -3:, -1]

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

     __A    :						Union[str, Any]						 =     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 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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

 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     pass







 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A    :						str						 =     self.get_dummy_components()
     __A    :						List[Any]						 =     StableDiffusionXLImgaImgPipeline(**__lowerCamelCase  )
     __A    :						Dict						 =     sd_pipe.to(__lowerCamelCase  )
     __A    :						Optional[Any]						 =     sd_pipe.to(__lowerCamelCase  )
     sd_pipe.set_progress_bar_config(disable=__lowerCamelCase  )

     # forward without prompt embeds
     __A    :						Dict						 =     self.get_dummy_inputs(__lowerCamelCase  )
     __A    :						List[str]						 =     3 * ['''this is a negative prompt''']
     __A    :						str						 =     negative_prompt
     __A    :						Dict						 =     3 * [inputs['''prompt''']]

     __A    :						Any						 =     sd_pipe(**__lowerCamelCase  )
     __A    :						Union[str, Any]						 =     output.images[0, -3:, -3:, -1]

     # forward with prompt embeds
     __A    :						Optional[int]						 =     self.get_dummy_inputs(__lowerCamelCase  )
     __A    :						Any						 =     3 * ['''this is a negative prompt''']
     __A    :						Tuple						 =     3 * [inputs.pop('''prompt'''  )]

     (
         (
         __A
     ) ,       (
         __A
     ) ,       (
         __A
     ) ,       (
         __A
     ) ,       
     )    :						Union[str, Any]						 =     sd_pipe.encode_prompt(__lowerCamelCase					,						negative_prompt=__lowerCamelCase  )

     __A    :						int						 =     sd_pipe(
         **__lowerCamelCase					,						prompt_embeds=__lowerCamelCase					,						negative_prompt_embeds=__lowerCamelCase					,						pooled_prompt_embeds=__lowerCamelCase					,						negative_pooled_prompt_embeds=__lowerCamelCase					,						)
     __A    :						Dict						 =     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 		__snake_case					(		unittest.TestCase     ):





 """simple docstring"""


 def 					UpperCamelCase__(    self  ):



     '''simple docstring'''




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

 def 					UpperCamelCase__(    self					,						__lowerCamelCase					,						__lowerCamelCase="cpu"					,						__lowerCamelCase=torch.floataa					,						__lowerCamelCase=0  ):



     '''simple docstring'''




     __A    :						int						 =     torch.Generator(device=__lowerCamelCase  ).manual_seed(__lowerCamelCase  )
     __A    :						str						 =     np.random.RandomState(__lowerCamelCase  ).standard_normal((1, 4, 64, 64)  )
     __A    :						Dict						 =     torch.from_numpy(__lowerCamelCase  ).to(device=__lowerCamelCase					,						dtype=__lowerCamelCase  )
     __A    :						Any						 =     {
         '''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 					UpperCamelCase__(    self  ):



     '''simple docstring'''




     __A    :						Union[str, Any]						 =     DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''  )
     pipe.to(__lowerCamelCase  )
     pipe.set_progress_bar_config(disable=__lowerCamelCase  )

     __A    :						List[Any]						 =     self.get_inputs(__lowerCamelCase  )
     __A    :						Optional[int]						 =     pipe(**__lowerCamelCase  ).images
     __A    :						Optional[int]						 =     image[0, -3:, -3:, -1].flatten()

     assert image.shape == (1, 512, 512, 3)
     __A    :						List[Any]						 =     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

a_ =			""""""  # <-- Put your OpenWeatherMap appid here!
a_ =			"""https://api.openweathermap.org/data/2.5/"""







def 		__lowercase     (   snake_case_  :  str = "Chicago"				,snake_case_  :  str = APPID						)   ->dict:



    '''simple docstring'''







    return requests.get(URL_BASE + '''weather'''				,params=locals()						).json()







def 		__lowercase     (   snake_case_  :  str = "Kolkata, India"				,snake_case_  :  str = APPID						)   ->dict:



    '''simple docstring'''







    return requests.get(URL_BASE + '''forecast'''				,params=locals()						).json()







def 		__lowercase     (   snake_case_  :  float = 55.68				,snake_case_  :  float = 12.57				,snake_case_  :  str = APPID						)   ->dict:



    '''simple docstring'''







    return requests.get(URL_BASE + '''onecall'''				,params=locals()						).json()


if __name__ == "__main__":
       from pprint import pprint

       while True:
              a_ =			input("""Enter a location:""").strip()
              if location:
                     pprint(current_weather(location))
              else:
                     break




