




from argparse import ArgumentParser

from . import BaseTransformersCLICommand


def    A						(__A   :    Any       )   ->      Tuple:







     """simple docstring"""


     return DownloadCommand(args.model   ,				args.cache_dir   ,				args.force   ,				args.trust_remote_code       )







class __snake_case			(			a		):







   @staticmethod
   def lowerCamelCase						(      _snake_case		:						ArgumentParser):

        """simple docstring"""


        UpperCAmelCase_          =							parser.add_parser('''download''')
        download_parser.add_argument(
            '''--cache-dir'''					,						type=_snake_case					,						default=_snake_case					,						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=_snake_case					,						help='''Name of the model to download''')
        download_parser.set_defaults(func=_snake_case)







   def __init__(      self		:						Tuple					,						_snake_case		:						str					,						_snake_case		:						str					,						_snake_case		:						bool					,						_snake_case		:						bool):

        """simple docstring"""


        UpperCAmelCase_          =							model
        UpperCAmelCase_          =							cache
        UpperCAmelCase_          =							force
        UpperCAmelCase_          =							trust_remote_code







   def lowerCamelCase						(      self		:						Union[str, Any]):

        """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)












# This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/

import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()







class __snake_case			(			a ,  a ,  a ,  unittest.TestCase		):
   UpperCAmelCase__  :    List[Any]          =  StableDiffusionControlNetImgaImgPipeline
   UpperCAmelCase__  :    Optional[Any]          =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
   UpperCAmelCase__  :    Optional[Any]          =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
   UpperCAmelCase__  :    Union[str, Any]          =  IMAGE_TO_IMAGE_IMAGE_PARAMS.union({'''control_image'''}		)
   UpperCAmelCase__  :    Optional[Any]          =  IMAGE_TO_IMAGE_IMAGE_PARAMS







   def lowerCamelCase						(      self		:						int):

        """simple docstring"""


        torch.manual_seed(0)
        UpperCAmelCase_          =							UNetaDConditionModel(
            block_out_channels=(32, 64)					,						layers_per_block=2					,						sample_size=32					,						in_channels=4					,						out_channels=4					,						down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')					,						up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')					,						cross_attention_dim=32					,						)
        torch.manual_seed(0)
        UpperCAmelCase_          =							ControlNetModel(
            block_out_channels=(32, 64)					,						layers_per_block=2					,						in_channels=4					,						down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')					,						cross_attention_dim=32					,						conditioning_embedding_out_channels=(16, 32)					,						)
        torch.manual_seed(0)
        UpperCAmelCase_          =							DDIMScheduler(
            beta_start=0.0_0_0_8_5					,						beta_end=0.0_1_2					,						beta_schedule='''scaled_linear'''					,						clip_sample=_snake_case					,						set_alpha_to_one=_snake_case					,						)
        torch.manual_seed(0)
        UpperCAmelCase_          =							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					,						)
        torch.manual_seed(0)
        UpperCAmelCase_          =							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					,						)
        UpperCAmelCase_          =							CLIPTextModel(_snake_case)
        UpperCAmelCase_          =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

        UpperCAmelCase_          =							{
            '''unet''': unet,
            '''controlnet''': controlnet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
            '''safety_checker''': None,
            '''feature_extractor''': None,
        }
        return components







   def lowerCamelCase						(      self		:						Union[str, Any]					,						_snake_case		:						Any					,						_snake_case		:						Dict=0):

        """simple docstring"""


        if str(_snake_case).startswith('''mps'''):
             UpperCAmelCase_          =							torch.manual_seed(_snake_case)
        else:
             UpperCAmelCase_          =							torch.Generator(device=_snake_case).manual_seed(_snake_case)

        UpperCAmelCase_          =							2
        UpperCAmelCase_          =							randn_tensor(
            (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)					,						generator=_snake_case					,						device=torch.device(_snake_case)					,						)
        UpperCAmelCase_          =							floats_tensor(control_image.shape					,						rng=random.Random(_snake_case)).to(_snake_case)
        UpperCAmelCase_          =							image.cpu().permute(0					,						2					,						3					,						1)[0]
        UpperCAmelCase_          =							Image.fromarray(np.uinta(_snake_case)).convert('''RGB''').resize((64, 64))
        UpperCAmelCase_          =							{
            '''prompt''': '''A painting of a squirrel eating a burger''',
            '''generator''': generator,
            '''num_inference_steps''': 2,
            '''guidance_scale''': 6.0,
            '''output_type''': '''numpy''',
            '''image''': image,
            '''control_image''': control_image,
        }

        return inputs







   def lowerCamelCase						(      self		:						Any):

        """simple docstring"""


        return self._test_attention_slicing_forward_pass(expected_max_diff=2e-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		:						Any):

        """simple docstring"""


        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3)







   def lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


        self._test_inference_batch_single_identical(expected_max_diff=2e-3)







class __snake_case			(			a ,  a ,  unittest.TestCase		):
   UpperCAmelCase__  :    str          =  StableDiffusionControlNetImgaImgPipeline
   UpperCAmelCase__  :    List[str]          =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
   UpperCAmelCase__  :    Optional[Any]          =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
   UpperCAmelCase__  :    str          =  frozenset([]		)  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess







   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


        torch.manual_seed(0)
        UpperCAmelCase_          =							UNetaDConditionModel(
            block_out_channels=(32, 64)					,						layers_per_block=2					,						sample_size=32					,						in_channels=4					,						out_channels=4					,						down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')					,						up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')					,						cross_attention_dim=32					,						)
        torch.manual_seed(0)

        def init_weights(_snake_case		:						Optional[int]):
             if isinstance(_snake_case					,						torch.nn.Convad):
                  torch.nn.init.normal(m.weight)
                  m.bias.data.fill_(1.0)

        UpperCAmelCase_          =							ControlNetModel(
            block_out_channels=(32, 64)					,						layers_per_block=2					,						in_channels=4					,						down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')					,						cross_attention_dim=32					,						conditioning_embedding_out_channels=(16, 32)					,						)
        controlneta.controlnet_down_blocks.apply(_snake_case)

        torch.manual_seed(0)
        UpperCAmelCase_          =							ControlNetModel(
            block_out_channels=(32, 64)					,						layers_per_block=2					,						in_channels=4					,						down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')					,						cross_attention_dim=32					,						conditioning_embedding_out_channels=(16, 32)					,						)
        controlneta.controlnet_down_blocks.apply(_snake_case)

        torch.manual_seed(0)
        UpperCAmelCase_          =							DDIMScheduler(
            beta_start=0.0_0_0_8_5					,						beta_end=0.0_1_2					,						beta_schedule='''scaled_linear'''					,						clip_sample=_snake_case					,						set_alpha_to_one=_snake_case					,						)
        torch.manual_seed(0)
        UpperCAmelCase_          =							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					,						)
        torch.manual_seed(0)
        UpperCAmelCase_          =							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					,						)
        UpperCAmelCase_          =							CLIPTextModel(_snake_case)
        UpperCAmelCase_          =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

        UpperCAmelCase_          =							MultiControlNetModel([controlneta, controlneta])

        UpperCAmelCase_          =							{
            '''unet''': unet,
            '''controlnet''': controlnet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
            '''safety_checker''': None,
            '''feature_extractor''': None,
        }
        return components







   def lowerCamelCase						(      self		:						int					,						_snake_case		:						Union[str, Any]					,						_snake_case		:						str=0):

        """simple docstring"""


        if str(_snake_case).startswith('''mps'''):
             UpperCAmelCase_          =							torch.manual_seed(_snake_case)
        else:
             UpperCAmelCase_          =							torch.Generator(device=_snake_case).manual_seed(_snake_case)

        UpperCAmelCase_          =							2

        UpperCAmelCase_          =							[
            randn_tensor(
                (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)					,						generator=_snake_case					,						device=torch.device(_snake_case)					,						),
            randn_tensor(
                (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)					,						generator=_snake_case					,						device=torch.device(_snake_case)					,						),
        ]

        UpperCAmelCase_          =							floats_tensor(control_image[0].shape					,						rng=random.Random(_snake_case)).to(_snake_case)
        UpperCAmelCase_          =							image.cpu().permute(0					,						2					,						3					,						1)[0]
        UpperCAmelCase_          =							Image.fromarray(np.uinta(_snake_case)).convert('''RGB''').resize((64, 64))
        UpperCAmelCase_          =							{
            '''prompt''': '''A painting of a squirrel eating a burger''',
            '''generator''': generator,
            '''num_inference_steps''': 2,
            '''guidance_scale''': 6.0,
            '''output_type''': '''numpy''',
            '''image''': image,
            '''control_image''': control_image,
        }

        return inputs







   def lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


        UpperCAmelCase_          =							self.get_dummy_components()
        UpperCAmelCase_          =							self.pipeline_class(**_snake_case)
        pipe.to(_snake_case)

        UpperCAmelCase_          =							1_0.0
        UpperCAmelCase_          =							4

        UpperCAmelCase_          =							self.get_dummy_inputs(_snake_case)
        UpperCAmelCase_          =							steps
        UpperCAmelCase_          =							scale
        UpperCAmelCase_          =							pipe(**_snake_case)[0]

        UpperCAmelCase_          =							self.get_dummy_inputs(_snake_case)
        UpperCAmelCase_          =							steps
        UpperCAmelCase_          =							scale
        UpperCAmelCase_          =							pipe(**_snake_case					,						control_guidance_start=0.1					,						control_guidance_end=0.2)[0]

        UpperCAmelCase_          =							self.get_dummy_inputs(_snake_case)
        UpperCAmelCase_          =							steps
        UpperCAmelCase_          =							scale
        UpperCAmelCase_          =							pipe(**_snake_case					,						control_guidance_start=[0.1, 0.3]					,						control_guidance_end=[0.2, 0.7])[0]

        UpperCAmelCase_          =							self.get_dummy_inputs(_snake_case)
        UpperCAmelCase_          =							steps
        UpperCAmelCase_          =							scale
        UpperCAmelCase_          =							pipe(**_snake_case					,						control_guidance_start=0.4					,						control_guidance_end=[0.5, 0.8])[0]

        # make sure that all outputs are different
        assert np.sum(np.abs(output_a - output_a)) > 1e-3
        assert np.sum(np.abs(output_a - output_a)) > 1e-3
        assert np.sum(np.abs(output_a - output_a)) > 1e-3







   def lowerCamelCase						(      self		:						Dict):

        """simple docstring"""


        return self._test_attention_slicing_forward_pass(expected_max_diff=2e-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		:						int):

        """simple docstring"""


        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3)







   def lowerCamelCase						(      self		:						int):

        """simple docstring"""


        self._test_inference_batch_single_identical(expected_max_diff=2e-3)







   def lowerCamelCase						(      self		:						Optional[int]):

        """simple docstring"""


        UpperCAmelCase_          =							self.get_dummy_components()
        UpperCAmelCase_          =							self.pipeline_class(**_snake_case)
        pipe.to(_snake_case)
        pipe.set_progress_bar_config(disable=_snake_case)
        with tempfile.TemporaryDirectory() as tmpdir:
             try:
                  # save_pretrained is not implemented for Multi-ControlNet
                  pipe.save_pretrained(_snake_case)
             except NotImplementedError:
                  pass







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







   def lowerCamelCase						(      self		:						Optional[int]):

        """simple docstring"""


        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







   def lowerCamelCase						(      self		:						Optional[int]):

        """simple docstring"""


        UpperCAmelCase_          =							ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny''')

        UpperCAmelCase_          =							StableDiffusionControlNetImgaImgPipeline.from_pretrained(
            '''runwayml/stable-diffusion-v1-5'''					,						safety_checker=_snake_case					,						controlnet=_snake_case)
        pipe.enable_model_cpu_offload()
        pipe.set_progress_bar_config(disable=_snake_case)

        UpperCAmelCase_          =							torch.Generator(device='''cpu''').manual_seed(0)
        UpperCAmelCase_          =							'''evil space-punk bird'''
        UpperCAmelCase_          =							load_image(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png''').resize((512, 512))
        UpperCAmelCase_          =							load_image(
            '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png''').resize((512, 512))

        UpperCAmelCase_          =							pipe(
            _snake_case					,						_snake_case					,						control_image=_snake_case					,						generator=_snake_case					,						output_type='''np'''					,						num_inference_steps=50					,						strength=0.6					,						)

        UpperCAmelCase_          =							output.images[0]

        assert image.shape == (512, 512, 3)

        UpperCAmelCase_          =							load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy''')

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






