

'''simple docstring'''







import gc
import unittest

import numpy as np
import torch

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, DPMSolverMultistepScheduler, TransformeraDModel
from diffusers.utils import is_xformers_available, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS,
    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()






class    A__ ( _snake_case  ,  unittest.TestCase     ):
    lowercase		   =						DiTPipeline
    lowercase		   =						CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
    lowercase		   =						PipelineTesterMixin.required_optional_params - {
        "latents",
        "num_images_per_prompt",
        "callback",
        "callback_steps",
    }
    lowercase		   =						CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
    lowercase		   =						False



    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           torch.manual_seed(0    )
           A_		   = TransformeraDModel(
               sample_size=16						,			num_layers=2						,			patch_size=4						,			attention_head_dim=8						,			num_attention_heads=2						,			in_channels=4						,			out_channels=8						,			attention_bias=UpperCamelCase__						,			activation_fn="""gelu-approximate"""						,			num_embeds_ada_norm=1000						,			norm_type="""ada_norm_zero"""						,			norm_elementwise_affine=UpperCamelCase__						,			)
           A_		   = AutoencoderKL()
           A_		   = DDIMScheduler()
           A_		   = {"""transformer""": transformer.eval(), """vae""": vae.eval(), """scheduler""": scheduler}
           return components



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__=0    )  -> List[str]:





           '''simple docstring'''
           if str(UpperCamelCase__    ).startswith("""mps"""    ):
                  A_		   = torch.manual_seed(UpperCamelCase__    )
           else:
                  A_		   = torch.Generator(device=UpperCamelCase__    ).manual_seed(UpperCamelCase__    )
           A_		   = {
               """class_labels""": [1],
               """generator""": generator,
               """num_inference_steps""": 2,
               """output_type""": """numpy""",
           }
           return inputs



    def    snake_case_     (   self    )  -> Union[str, Any]:





           '''simple docstring'''
           A_		   = """cpu"""

           A_		   = self.get_dummy_components()
           A_		   = self.pipeline_class(**UpperCamelCase__    )
           pipe.to(UpperCamelCase__    )
           pipe.set_progress_bar_config(disable=UpperCamelCase__    )

           A_		   = self.get_dummy_inputs(UpperCamelCase__    )
           A_		   = pipe(**UpperCamelCase__    ).images
           A_		   = image[0, -3:, -3:, -1]

           self.assertEqual(image.shape						,			(1, 16, 16, 3)    )
           A_		   = np.array([0.2946, 0.6601, 0.4329, 0.3296, 0.4144, 0.5319, 0.7273, 0.5013, 0.4457]    )
           A_		   = np.abs(image_slice.flatten() - expected_slice    ).max()
           self.assertLessEqual(UpperCamelCase__						,			1e-3    )



    def    snake_case_     (   self    )  -> Union[str, Any]:





           '''simple docstring'''
           self._test_inference_batch_single_identical(relax_max_difference=UpperCamelCase__						,			expected_max_diff=1e-3    )







    @unittest.skipIf(
        torch_device != """cuda""" or not is_xformers_available()						,			reason="""XFormers attention is only available with CUDA and `xformers` installed"""						,			)
    def    snake_case_     (   self    )  -> Optional[int]:





           '''simple docstring'''
           self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3    )






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



    def    snake_case_     (   self    )  -> List[str]:





           '''simple docstring'''
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()



    def    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           A_		   = torch.manual_seed(0    )

           A_		   = DiTPipeline.from_pretrained("""facebook/DiT-XL-2-256"""    )
           pipe.to("""cuda"""    )

           A_		   = ["""vase""", """umbrella""", """white shark""", """white wolf"""]
           A_		   = pipe.get_label_ids(UpperCamelCase__    )

           A_		   = pipe(UpperCamelCase__						,			generator=UpperCamelCase__						,			num_inference_steps=40						,			output_type="""np"""    ).images

           for word, image in zip(UpperCamelCase__						,			UpperCamelCase__    ):
                  A_		   = load_numpy(
                      f'''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/dit/{word}.npy'''    )
                  assert np.abs((expected_image - image).max()    ) < 1e-2







    def    snake_case_     (   self    )  -> List[str]:





           '''simple docstring'''
           A_		   = DiTPipeline.from_pretrained("""facebook/DiT-XL-2-512"""    )
           A_		   = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config    )
           pipe.to("""cuda"""    )

           A_		   = ["""vase""", """umbrella"""]
           A_		   = pipe.get_label_ids(UpperCamelCase__    )

           A_		   = torch.manual_seed(0    )
           A_		   = pipe(UpperCamelCase__						,			generator=UpperCamelCase__						,			num_inference_steps=25						,			output_type="""np"""    ).images

           for word, image in zip(UpperCamelCase__						,			UpperCamelCase__    ):
                  A_		   = load_numpy(
                      """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                      f'''/dit/{word}_512.npy'''    )

                  assert np.abs((expected_image - image).max()    ) < 1e-1



'''simple docstring'''







import requests

__lowerCamelCase						    =      ''''''  # <-- Put your OpenWeatherMap appid here!
__lowerCamelCase						    =      '''https://api.openweathermap.org/data/2.5/'''
def  UpperCAmelCase__      ( UpperCAmelCase__ = "Chicago",    UpperCAmelCase__ = APPID			)     ->     dict:
       return requests.get(URL_BASE + """weather""",    params=locals()			).json()
def  UpperCAmelCase__      ( UpperCAmelCase__ = "Kolkata, India",    UpperCAmelCase__ = APPID			)     ->     dict:
       return requests.get(URL_BASE + """forecast""",    params=locals()			).json()
def  UpperCAmelCase__      ( UpperCAmelCase__ = 55.68,    UpperCAmelCase__ = 12.57,    UpperCAmelCase__ = APPID			)     ->     dict:
       return requests.get(URL_BASE + """onecall""",    params=locals()			).json()


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

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