
'''simple docstring'''





import random
import unittest

import torch

from diffusers import IFSuperResolutionPipeline
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 			UpperCamelCase__	(     SCREAMING_SNAKE_CASE   ,  SCREAMING_SNAKE_CASE   ,  unittest.TestCase):
 UpperCAmelCase__     :     Union[str, Any]    					=       IFSuperResolutionPipeline
 UpperCAmelCase__     :     str    					=       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
 UpperCAmelCase__     :     List[Any]    					=       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 UpperCAmelCase__     :     Optional[Any]    					=       PipelineTesterMixin.required_optional_params - {'latents'}






 def 						lowercase_    (      self	:Any      )					->      Dict:







       '''simple docstring'''



       return self._get_superresolution_dummy_components()






 def 						lowercase_    (      self	:Optional[int]						,					_A	:Optional[int]						,					_A	:Optional[Any]=0      )					->      List[str]:







       '''simple docstring'''



       if str(_A      ).startswith('mps'      ):
             __A													=      torch.manual_seed(_A      )
       else:
             __A													=      torch.Generator(device=_A      ).manual_seed(_A      )

       __A													=      floats_tensor((1, 3, 32, 32)						,					rng=random.Random(_A      )      ).to(_A      )

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

       return inputs






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







       '''simple docstring'''



       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3      )






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







       '''simple docstring'''



       self._test_save_load_optional_components()






 @unittest.skipIf(torch_device != 'cuda'						,					reason='float16 requires CUDA'      )
 def 						lowercase_    (      self	:List[str]      )					->      Union[str, Any]:







       '''simple docstring'''



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






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







       '''simple docstring'''



       self._test_attention_slicing_forward_pass(expected_max_diff=1E-2      )






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







       '''simple docstring'''



       self._test_save_load_local()






 def 						lowercase_    (      self	:Optional[int]      )					->      Dict:







       '''simple docstring'''



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














import json

import requests

from .fetch_github_info import AUTHENTICATED_USER_ENDPOINT, fetch_github_info
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    class        snake_case_				:







       """simple docstring"""



       def __init__(     self:						Tuple ,							snake_case__:						Optional[int]						)	->		None:


           """simple docstring"""



           assert isinstance(snake_case__ ,							(bytes, str)						)
           _lowercase     			=						content

       def       SCREAMING_SNAKE_CASE__					(     self:						Tuple						)	->		str:


           """simple docstring"""



           return json.loads(self.content						)

    def mock_response(*_lowercase,   **_lowercase   ):
        assert args[0] == AUTHENTICATED_USER_ENDPOINT
        assert "Authorization" in kwargs["headers"]
        assert kwargs["headers"]["Authorization"].startswith('token '   )
        assert "Accept" in kwargs["headers"]
        return FakeResponse(b'{"login":"test","id":1}'   )

    monkeypatch.setattr(_lowercase,   'get',   _lowercase   )
    _lowercase     			=						fetch_github_info('token'   )
    assert result["login"] == "test"
    assert result["id"] == 1
