



from argparse import ArgumentParser

from . import BaseTransformersCLICommand






def  UpperCAmelCase__    (    lowercase__   ) ->      List[str]:
						return DownloadCommand(args.model						,       args.cache_dir						,       args.force						,       args.trust_remote_code   )







class 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			@staticmethod
			def 		snake_case__			(				lowercase	:       ArgumentParser   )						->					str:
									"""simple docstring"""







									__lowercase					=				parser.add_parser("""download"""   )
									download_parser.add_argument(
									    """--cache-dir"""			,     type=lowercase			,     default=lowercase			,     help="""Path to location to store the models"""   )
									download_parser.add_argument(
									    """--force"""			,     action="""store_true"""			,     help="""Force the model to be download even if already in cache-dir"""   )
									download_parser.add_argument(
									    """--trust-remote-code"""			,     action="""store_true"""			,     help="""Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you've reviewed the code as it will execute on your local machine"""			,     )
									download_parser.add_argument("""model"""			,     type=lowercase			,     help="""Name of the model to download"""   )
									download_parser.set_defaults(func=lowercase   )





			def __init__(				self	:       int			,     lowercase	:       str			,     lowercase	:       str			,     lowercase	:       bool			,     lowercase	:       bool   )						->					Any:
									"""simple docstring"""







									__lowercase					=				model
									__lowercase					=				cache
									__lowercase					=				force
									__lowercase					=				trust_remote_code







			def 		snake_case__			(				self	:       Optional[Any]   )						->					List[str]:
									"""simple docstring"""







									from ..models.auto import AutoModel, AutoTokenizer

									AutoModel.from_pretrained(
									    self._model			,     cache_dir=self._cache			,     force_download=self._force			,     trust_remote_code=self._trust_remote_code   )
									AutoTokenizer.from_pretrained(
									    self._model			,     cache_dir=self._cache			,     force_download=self._force			,     trust_remote_code=self._trust_remote_code   )










import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
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 			_lowerCAmelCase   ( _UpperCAmelCase    ,					_UpperCAmelCase    ,					unittest.TestCase			):






			"""simple docstring"""





			lowercase__      :  int      =			IFImgaImgSuperResolutionPipeline
			lowercase__      :  Optional[int]      =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
			lowercase__      :  Optional[int]      =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}			)
			lowercase__      :  Tuple      =			PipelineTesterMixin.required_optional_params - {"""latents"""}





			def 		snake_case__			(				self	:       Tuple   )						->					Any:
									"""simple docstring"""







									return self._get_superresolution_dummy_components()





			def 		snake_case__			(				self	:       List[str]			,     lowercase	:       Optional[int]			,     lowercase	:       Optional[Any]=0   )						->					Union[str, Any]:
									"""simple docstring"""







									if str(lowercase   ).startswith("""mps"""   ):
															__lowercase					=				torch.manual_seed(lowercase   )
									else:
															__lowercase					=				torch.Generator(device=lowercase   ).manual_seed(lowercase   )

									__lowercase					=				floats_tensor((1, 3, 32, 32)			,     rng=random.Random(lowercase   )   ).to(lowercase   )
									__lowercase					=				floats_tensor((1, 3, 16, 16)			,     rng=random.Random(lowercase   )   ).to(lowercase   )

									__lowercase					=				{
									    """prompt""": """A painting of a squirrel eating a burger""",
									    """image""": image,
									    """original_image""": original_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 		snake_case__			(				self	:       Optional[Any]   )						->					Tuple:
									"""simple docstring"""







									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )





			def 		snake_case__			(				self	:       List[Any]   )						->					Union[str, Any]:
									"""simple docstring"""







									self._test_save_load_optional_components()





			@unittest.skipIf(torch_device != """cuda"""			,     reason="""float16 requires CUDA"""   )
			def 		snake_case__			(				self	:       List[Any]   )						->					Dict:
									"""simple docstring"""







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





			def 		snake_case__			(				self	:       Dict   )						->					int:
									"""simple docstring"""







									self._test_attention_slicing_forward_pass(expected_max_diff=1E-2   )





			def 		snake_case__			(				self	:       Optional[Any]   )						->					int:
									"""simple docstring"""







									self._test_save_load_local()







			def 		snake_case__			(				self	:       Optional[int]   )						->					Optional[int]:
									"""simple docstring"""







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





