



import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()






@skip_mps
class SCREAMING_SNAKE_CASE__					(		SCREAMING_SNAKE_CASE__			,						unittest.TestCase   ):




    '''simple docstring'''






    __lowerCamelCase      :			int =				TextToVideoSDPipeline
    __lowerCamelCase      :			str =				TEXT_TO_IMAGE_PARAMS
    __lowerCamelCase      :			List[str] =				TEXT_TO_IMAGE_BATCH_PARAMS
    # No `output_type`.
    __lowerCamelCase      :			Dict =				frozenset(
        [
            "num_inference_steps",
            "generator",
            "latents",
            "return_dict",
            "callback",
            "callback_steps",
        ]   )






    def       _lowerCAmelCase (	self		):
        torch.manual_seed(0		)
        A			:	str										=       UNetaDConditionModel(
            block_out_channels=(32, 64, 64, 64),		layers_per_block=2,		sample_size=32,		in_channels=4,		out_channels=4,		down_block_types=("""CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """DownBlock3D"""),		up_block_types=("""UpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D"""),		cross_attention_dim=32,		attention_head_dim=4,		)
        A			:	Optional[Any]										=       DDIMScheduler(
            beta_start=0.0_0085,		beta_end=0.012,		beta_schedule="""scaled_linear""",		clip_sample=lowerCamelCase__,		set_alpha_to_one=lowerCamelCase__,		)
        torch.manual_seed(0		)
        A			:	str										=       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			:	Union[str, Any]										=       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=1000,		hidden_act="""gelu""",		projection_dim=512,		)
        A			:	int										=       CLIPTextModel(lowerCamelCase__		)
        A			:	List[Any]										=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""		)

        A			:	List[str]										=       {
            """unet""": unet,
            """scheduler""": scheduler,
            """vae""": vae,
            """text_encoder""": text_encoder,
            """tokenizer""": tokenizer,
        }
        return components






    def       _lowerCAmelCase (	self,		lowerCamelCase__,		lowerCamelCase__=0		):
        if str(lowerCamelCase__		).startswith("""mps"""		):
            A			:	Optional[int]										=       torch.manual_seed(lowerCamelCase__		)
        else:
            A			:	Optional[int]										=       torch.Generator(device=lowerCamelCase__		).manual_seed(lowerCamelCase__		)
        A			:	Any										=       {
            """prompt""": """A painting of a squirrel eating a burger""",
            """generator""": generator,
            """num_inference_steps""": 2,
            """guidance_scale""": 6.0,
            """output_type""": """pt""",
        }
        return inputs






    def       _lowerCAmelCase (	self		):
        A			:	Dict										=       """cpu"""  # ensure determinism for the device-dependent torch.Generator
        A			:	Tuple										=       self.get_dummy_components()
        A			:	Dict										=       TextToVideoSDPipeline(**lowerCamelCase__		)
        A			:	List[Any]										=       sd_pipe.to(lowerCamelCase__		)
        sd_pipe.set_progress_bar_config(disable=lowerCamelCase__		)

        A			:	int										=       self.get_dummy_inputs(lowerCamelCase__		)
        A			:	Any										=       """np"""
        A			:	Optional[int]										=       sd_pipe(**lowerCamelCase__		).frames
        A			:	str										=       frames[0][-3:, -3:, -1]

        assert frames[0].shape == (64, 64, 3)
        A			:	Optional[Any]										=       np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0]		)

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






    def       _lowerCAmelCase (	self		):
        self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCamelCase__,		expected_max_diff=3e-3		)






    @unittest.skipIf(
        torch_device != """cuda""" or not is_xformers_available(),		reason="""XFormers attention is only available with CUDA and `xformers` installed""",		)
    def       _lowerCAmelCase (	self		):
        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCamelCase__,		expected_max_diff=1e-2		)






    @unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""		)
    def       _lowerCAmelCase (	self		):
        pass






    @unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""		)
    def       _lowerCAmelCase (	self		):
        pass






    @unittest.skip(reason="""`num_images_per_prompt` argument is not supported for this pipeline."""		)
    def       _lowerCAmelCase (	self		):
        pass






    def       _lowerCAmelCase (	self		):
        return super().test_progress_bar()






@slow
@skip_mps
class SCREAMING_SNAKE_CASE__					(		unittest.TestCase   ):




    '''simple docstring'''






    def       _lowerCAmelCase (	self		):
        A			:	int										=       load_numpy(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"""		)

        A			:	int										=       TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""		)
        A			:	Optional[int]										=       DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
        A			:	Optional[int]										=       pipe.to("""cuda"""		)

        A			:	int										=       """Spiderman is surfing"""
        A			:	int										=       torch.Generator(device="""cpu"""		).manual_seed(0		)

        A			:	List[Any]										=       pipe(lowerCamelCase__,		generator=lowerCamelCase__,		num_inference_steps=25,		output_type="""pt"""		).frames
        A			:	Optional[int]										=       video_frames.cpu().numpy()

        assert np.abs(expected_video - video		).mean() < 5e-2






    def       _lowerCAmelCase (	self		):
        A			:	Any										=       load_numpy(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"""		)

        A			:	str										=       TextToVideoSDPipeline.from_pretrained("""damo-vilab/text-to-video-ms-1.7b"""		)
        A			:	Dict										=       pipe.to("""cuda"""		)

        A			:	int										=       """Spiderman is surfing"""
        A			:	Any										=       torch.Generator(device="""cpu"""		).manual_seed(0		)

        A			:	Dict										=       pipe(lowerCamelCase__,		generator=lowerCamelCase__,		num_inference_steps=2,		output_type="""pt"""		).frames
        A			:	List[Any]										=       video_frames.cpu().numpy()

        assert np.abs(expected_video - video		).mean() < 5e-2







import requests

SCREAMING_SNAKE_CASE_:List[str]					=						""""""  # <-- Put your OpenWeatherMap appid here!
SCREAMING_SNAKE_CASE_:Dict					=						"""https://api.openweathermap.org/data/2.5/"""




def      __UpperCamelCase     (  _lowerCAmelCase = "Chicago"				,					_lowerCAmelCase = APPID		)	->  dict:



    """simple docstring"""






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




def      __UpperCamelCase     (  _lowerCAmelCase = "Kolkata, India"				,					_lowerCAmelCase = APPID		)	->  dict:



    """simple docstring"""






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




def      __UpperCamelCase     (  _lowerCAmelCase = 55.68				,					_lowerCAmelCase = 12.57				,					_lowerCAmelCase = APPID		)	->  dict:



    """simple docstring"""






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


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

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


