
"""simple docstring"""




import random
import unittest

import torch

from diffusers import IFImgaImgPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin







@skip_mps
class 						lowercase(_lowercase						,	_lowercase						,	unittest.TestCase					):
     __snake_case:  Optional[Any]  				=    IFImgaImgPipeline
     __snake_case:  Dict  				=    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
     __snake_case:  int  				=    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     __snake_case:  str  				=    PipelineTesterMixin.required_optional_params - {'latents'}



     def  lowercase__     (       self      )		->    Optional[Any]:







         """simple docstring"""



         return self._get_dummy_components()



     def  lowercase__     (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE=0      )		->    List[str]:







         """simple docstring"""



         if str(__SCREAMING_SNAKE_CASE      ).startswith('mps'      ):
             a__    = torch.manual_seed(__SCREAMING_SNAKE_CASE      )
         else:
             a__    = torch.Generator(device=__SCREAMING_SNAKE_CASE      ).manual_seed(__SCREAMING_SNAKE_CASE      )

         a__    = floats_tensor((1, 3, 3_2, 3_2)    ,							rng=random.Random(__SCREAMING_SNAKE_CASE      )      ).to(__SCREAMING_SNAKE_CASE      )

         a__    = {
             'prompt': 'A painting of a squirrel eating a burger',
             'image': image,
             'generator': generator,
             'num_inference_steps': 2,
             'output_type': 'numpy',
         }

         return inputs



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







         """simple docstring"""



         self._test_save_load_optional_components()



     @unittest.skipIf(
         torch_device != 'cuda' or not is_xformers_available()    ,							reason='XFormers attention is only available with CUDA and `xformers` installed'    ,							)
     def  lowercase__     (       self      )		->    Union[str, Any]:







         """simple docstring"""



         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3      )



     @unittest.skipIf(torch_device != 'cuda'    ,							reason='float16 requires CUDA'      )
     def  lowercase__     (       self      )		->    Dict:







         """simple docstring"""



         super().test_save_load_floataa(expected_max_diff=1e-1      )



     @unittest.skipIf(torch_device != 'cuda'    ,							reason='float16 requires CUDA'      )
     def  lowercase__     (       self      )		->    Tuple:







         """simple docstring"""



         super().test_floataa_inference(expected_max_diff=1e-1      )



     def  lowercase__     (       self      )		->    Any:







         """simple docstring"""



         self._test_attention_slicing_forward_pass(expected_max_diff=1e-2      )



     def  lowercase__     (       self      )		->    Optional[Any]:







         """simple docstring"""



         self._test_save_load_local()




     def  lowercase__     (       self      )		->    Dict:







         """simple docstring"""



         self._test_inference_batch_single_identical(
             expected_max_diff=1e-2    ,							)




"""simple docstring"""




import shutil

import requests



def 						__magic_name__		(				UpperCamelCase    :		str       ,		UpperCamelCase    :		bool = False       ,		UpperCamelCase    :		str = "."    )    ->	dict:
    a__    = 'https://api.nasa.gov/planetary/apod'
    return requests.get(UpperCamelCase       ,		params={'api_key': api_key}    ).json()



def 						__magic_name__		(				UpperCamelCase    :		str       ,		UpperCamelCase    :		str = "."    )    ->	dict:
    a__    = get_apod_data(UpperCamelCase    )
    a__    = apod_data['url']
    a__    = img_url.split('/'    )[-1]
    a__    = requests.get(UpperCamelCase       ,		stream=UpperCamelCase    )

    with open(f'{path}/{img_name}'       ,		'wb+'    ) as img_file:
        shutil.copyfileobj(response.raw       ,		UpperCamelCase    )
    del response
    return apod_data



def 						__magic_name__		(				UpperCamelCase    :		str    )    ->	dict:
    a__    = 'https://images-api.nasa.gov/search'
    return requests.get(UpperCamelCase       ,		params={'q': query}    ).json()


if __name__ == "__main__":
    print(save_apod('YOUR API KEY'))
    a		:					List[Any]    	=					get_archive_data('apollo 2011')['collection']['items']
    print(apollo_aaaa_items[0]['data'][0]['description'])


