import torch.nn as nn

from .imports import is_fpa_available


if is_fpa_available():
 import transformer_engine.pytorch as te


def SCREAMING_SNAKE_CASE			(       lowercase_:		int						,  lowercase_:		Any=True						,  lowercase_:		List[Any]=True						,  lowercase_:		Tuple=True ):



       if not is_fpa_available():
              raise ImportError('Using `convert_model` requires transformer_engine to be installed.' )
       for name, module in model.named_children():
              if isinstance(UpperCamelCase_						,  nn.Linear ) and to_transformer_engine and _convert_linear:
                     # Return early if the linear layer weights are not multiples of 16
                     if any(p % 16 != 0 for p in module.weight.shape ):
                            return
                     _UpperCamelCase       :    Any					  =					module.bias is not None
                     _UpperCamelCase       :    List[str]					  =					te.Linear(
                         module.in_features						,  module.out_features						,  bias=UpperCamelCase_						,  params_dtype=module.weight.dtype )
                     _UpperCamelCase       :    str					  =					module.weight.data.clone()
                     if has_bias:
                            _UpperCamelCase       :    List[Any]					  =					module.bias.data.clone()

                     setattr(UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_ )
              elif isinstance(UpperCamelCase_						,  nn.LayerNorm ) and to_transformer_engine and _convert_ln:
                     _UpperCamelCase       :    Any					  =					te.LayerNorm(module.normalized_shape[0]						,  eps=module.eps						,  params_dtype=module.weight.dtype )
                     _UpperCamelCase       :    Dict					  =					module.weight.data.clone()
                     _UpperCamelCase       :    Tuple					  =					module.bias.data.clone()

                     setattr(UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_ )
              elif isinstance(UpperCamelCase_						,  te.Linear ) and not to_transformer_engine and _convert_linear:
                     _UpperCamelCase       :    Dict					  =					module.bias is not None
                     _UpperCamelCase       :    int					  =					nn.Linear(
                         module.in_features						,  module.out_features						,  bias=UpperCamelCase_						,  params_dtype=module.weight.dtype )
                     _UpperCamelCase       :    str					  =					module.weight.data.clone()
                     if has_bias:
                            _UpperCamelCase       :    Tuple					  =					module.bias.data.clone()

                     setattr(UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_ )
              elif isinstance(UpperCamelCase_						,  te.LayerNorm ) and not to_transformer_engine and _convert_ln:
                     _UpperCamelCase       :    Tuple					  =					nn.LayerNorm(module.normalized_shape[0]						,  eps=module.eps						,  params_dtype=module.weight.dtype )
                     _UpperCamelCase       :    Dict					  =					module.weight.data.clone()
                     _UpperCamelCase       :    int					  =					module.bias.data.clone()

                     setattr(UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_ )
              else:
                     convert_model(
                         UpperCamelCase_						,  to_transformer_engine=UpperCamelCase_						,  _convert_linear=_convert_linear						,  _convert_ln=_convert_ln						,  )





def SCREAMING_SNAKE_CASE			(       lowercase_:		Tuple ):



       if not is_fpa_available():
              raise ImportError('Using `has_transformer_engine_layers` requires transformer_engine to be installed.' )
       for m in model.modules():
              if isinstance(UpperCamelCase_						,  (te.LayerNorm, te.Linear) ):
                     return True
       return False




import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionDualGuidedPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


UpperCAmelCase     						=			False




@nightly
@require_torch_gpu
class 				__lowerCAmelCase					(    unittest.TestCase  ):



 '''simple docstring'''

 def    __snake_case   (     self    :						Optional[Any]					)	->							str:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()

 def    __snake_case   (     self    :						Dict					)	->							str:
        _UpperCamelCase       :    Dict					  =					VersatileDiffusionDualGuidedPipeline.from_pretrained('shi-labs/versatile-diffusion'					)
        # remove text_unet
        pipe.remove_unused_weights()
        pipe.to(lowerCamelCase					)
        pipe.set_progress_bar_config(disable=lowerCamelCase					)

        _UpperCamelCase       :    Dict					  =					load_image(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'					)

        _UpperCamelCase       :    Optional[int]					  =					torch.manual_seed(0					)
        _UpperCamelCase       :    Optional[Any]					  =					pipe(
            prompt='first prompt'    ,     image=lowerCamelCase    ,     text_to_image_strength=0.7_5    ,     generator=lowerCamelCase    ,     guidance_scale=7.5    ,     num_inference_steps=2    ,     output_type='numpy'    ,     ).images

        with tempfile.TemporaryDirectory() as tmpdirname:
               pipe.save_pretrained(lowerCamelCase					)
               _UpperCamelCase       :    int					  =					VersatileDiffusionDualGuidedPipeline.from_pretrained(lowerCamelCase					)

        pipe.to(lowerCamelCase					)
        pipe.set_progress_bar_config(disable=lowerCamelCase					)

        _UpperCamelCase       :    str					  =					generator.manual_seed(0					)
        _UpperCamelCase       :    Tuple					  =					pipe(
            prompt='first prompt'    ,     image=lowerCamelCase    ,     text_to_image_strength=0.7_5    ,     generator=lowerCamelCase    ,     guidance_scale=7.5    ,     num_inference_steps=2    ,     output_type='numpy'    ,     ).images

        assert np.abs(image - new_image					).sum() < 1e-5, "Models don't have the same forward pass"

 def    __snake_case   (     self    :						Tuple					)	->							Optional[int]:
        _UpperCamelCase       :    Optional[Any]					  =					VersatileDiffusionDualGuidedPipeline.from_pretrained('shi-labs/versatile-diffusion'					)
        pipe.remove_unused_weights()
        pipe.to(lowerCamelCase					)
        pipe.set_progress_bar_config(disable=lowerCamelCase					)

        _UpperCamelCase       :    Union[str, Any]					  =					'cyberpunk 2077'
        _UpperCamelCase       :    str					  =					load_image(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'					)
        _UpperCamelCase       :    List[Any]					  =					torch.manual_seed(0					)
        _UpperCamelCase       :    Optional[Any]					  =					pipe(
            prompt=lowerCamelCase    ,     image=lowerCamelCase    ,     text_to_image_strength=0.7_5    ,     generator=lowerCamelCase    ,     guidance_scale=7.5    ,     num_inference_steps=5_0    ,     output_type='numpy'    ,     ).images

        _UpperCamelCase       :    Any					  =					image[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1]

        assert image.shape == (1, 5_1_2, 5_1_2, 3)
        _UpperCamelCase       :    Optional[int]					  =					np.array([0.0_7_8_7, 0.0_8_4_9, 0.0_8_2_6, 0.0_8_1_2, 0.0_8_0_7, 0.0_7_9_5, 0.0_8_1_8, 0.0_7_9_8, 0.0_7_7_9]					)

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



