


'''simple docstring'''



import gc
import math
import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, logging, slow, torch_all_close, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


A__		:					str												=  logging.get_logger(__name__)

enable_full_determinism()





class    UpperCAmelCase_  (_UpperCAmelCase					,		_UpperCAmelCase					,		unittest.TestCase  ):





    """simple docstring"""






    lowerCamelCase  :					Optional[Any]							     =			UNetaDModel
    lowerCamelCase  :					List[str]							     =			'sample'







    @property
    def       lowercase_				(							self	)				->     Tuple:
         __lowerCamelCase   :	List[str]								=		4
         __lowerCamelCase   :	str								=		3
         __lowerCamelCase   :	List[str]								=		(32, 32)

         __lowerCamelCase   :	Tuple								=		floats_tensor((batch_size, num_channels) + sizes	).to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Optional[Any]								=		torch.tensor([10]	).to(SCREAMING_SNAKE_CASE_	)

         return {"sample": noise, "timestep": time_step}







    @property
    def       lowercase_				(							self	)				->     Any:
         return (3, 32, 32)







    @property
    def       lowercase_				(							self	)				->     str:
         return (3, 32, 32)







    def       lowercase_				(							self	)				->     Dict:
         __lowerCamelCase   :	Union[str, Any]								=		{
             'block_out_channels': (32, 64),
             'down_block_types': ('DownBlock2D', 'AttnDownBlock2D'),
             'up_block_types': ('AttnUpBlock2D', 'UpBlock2D'),
             'attention_head_dim': 3,
             'out_channels': 3,
             'in_channels': 3,
             'layers_per_block': 2,
             'sample_size': 32,
         }
         __lowerCamelCase   :	Tuple								=		self.dummy_input
         return init_dict, inputs_dict







class    UpperCAmelCase_  (_UpperCAmelCase					,		_UpperCAmelCase					,		unittest.TestCase  ):





    """simple docstring"""






    lowerCamelCase  :					Any							     =			UNetaDModel
    lowerCamelCase  :					List[Any]							     =			'sample'







    @property
    def       lowercase_				(							self	)				->     List[str]:
         __lowerCamelCase   :	Dict								=		4
         __lowerCamelCase   :	int								=		4
         __lowerCamelCase   :	List[str]								=		(32, 32)

         __lowerCamelCase   :	List[str]								=		floats_tensor((batch_size, num_channels) + sizes	).to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Tuple								=		torch.tensor([10]	).to(SCREAMING_SNAKE_CASE_	)

         return {"sample": noise, "timestep": time_step}







    @property
    def       lowercase_				(							self	)				->     Optional[Any]:
         return (4, 32, 32)







    @property
    def       lowercase_				(							self	)				->     Optional[Any]:
         return (4, 32, 32)







    def       lowercase_				(							self	)				->     Optional[int]:
         __lowerCamelCase   :	Optional[int]								=		{
             'sample_size': 32,
             'in_channels': 4,
             'out_channels': 4,
             'layers_per_block': 2,
             'block_out_channels': (32, 64),
             'attention_head_dim': 32,
             'down_block_types': ('DownBlock2D', 'DownBlock2D'),
             'up_block_types': ('UpBlock2D', 'UpBlock2D'),
         }
         __lowerCamelCase   :	Any								=		self.dummy_input
         return init_dict, inputs_dict







    def       lowercase_				(							self	)				->     List[str]:
         __lowerCamelCase				,       __lowerCamelCase   :	str								=		UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update'			,     output_loading_info=SCREAMING_SNAKE_CASE_	)

         self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)
         self.assertEqual(len(loading_info['missing_keys']	)			,     0	)

         model.to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	List[str]								=		model(**self.dummy_input	).sample

         assert image is not None, "Make sure output is not None"







    @unittest.skipIf(torch_device != 'cuda'			,     'This test is supposed to run on GPU'	)
    def       lowercase_				(							self	)				->     Dict:
         __lowerCamelCase				,       __lowerCamelCase   :	Optional[Any]								=		UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update'			,     output_loading_info=SCREAMING_SNAKE_CASE_	)
         model.to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	List[str]								=		model(**self.dummy_input	).sample

         assert image is not None, "Make sure output is not None"







    @unittest.skipIf(torch_device != 'cuda'			,     'This test is supposed to run on GPU'	)
    def       lowercase_				(							self	)				->     int:
         # by defautl model loading will use accelerate as `low_cpu_mem_usage=True`
         __lowerCamelCase				,       __lowerCamelCase   :	str								=		UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update'			,     output_loading_info=SCREAMING_SNAKE_CASE_	)
         model_accelerate.to(SCREAMING_SNAKE_CASE_	)
         model_accelerate.eval()

         __lowerCamelCase   :	Dict								=		torch.randn(
             1			,     model_accelerate.config.in_channels			,     model_accelerate.config.sample_size			,     model_accelerate.config.sample_size			,     generator=torch.manual_seed(0	)			,     )
         __lowerCamelCase   :	List[Any]								=		noise.to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Optional[int]								=		torch.tensor([10] * noise.shape[0]	).to(SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	List[str]								=		model_accelerate(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_	)['sample']

         # two models don't need to stay in the device at the same time
         del model_accelerate
         torch.cuda.empty_cache()
         gc.collect()

         __lowerCamelCase				,       __lowerCamelCase   :	Union[str, Any]								=		UNetaDModel.from_pretrained(
             'fusing/unet-ldm-dummy-update'			,     output_loading_info=SCREAMING_SNAKE_CASE_			,     low_cpu_mem_usage=SCREAMING_SNAKE_CASE_	)
         model_normal_load.to(SCREAMING_SNAKE_CASE_	)
         model_normal_load.eval()
         __lowerCamelCase   :	List[Any]								=		model_normal_load(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_	)['sample']

         assert torch_all_close(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     rtol=1E-3	)







    def       lowercase_				(							self	)				->     Optional[int]:
         __lowerCamelCase   :	str								=		UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update'	)
         model.eval()
         model.to(SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	List[Any]								=		torch.randn(
             1			,     model.config.in_channels			,     model.config.sample_size			,     model.config.sample_size			,     generator=torch.manual_seed(0	)			,     )
         __lowerCamelCase   :	Optional[int]								=		noise.to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Dict								=		torch.tensor([10] * noise.shape[0]	).to(SCREAMING_SNAKE_CASE_	)

         with torch.no_grad():
              __lowerCamelCase   :	Any								=		model(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_	).sample

         __lowerCamelCase   :	str								=		output[0, -1, -3:, -3:].flatten().cpu()
         # fmt: off
         __lowerCamelCase   :	Optional[int]								=		torch.tensor([-1_3.3_2_5_8, -2_0.1_1_0_0, -1_5.9_8_7_3, -1_7.6_6_1_7, -2_3.0_5_9_6, -1_7.9_4_1_9, -1_3.3_6_7_5, -1_6.1_8_8_9, -1_2.3_8_0_0]	)
         # fmt: on

         self.assertTrue(torch_all_close(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     rtol=1E-3	)	)







class    UpperCAmelCase_  (_UpperCAmelCase					,		_UpperCAmelCase					,		unittest.TestCase  ):





    """simple docstring"""






    lowerCamelCase  :					Dict							     =			UNetaDModel
    lowerCamelCase  :					Union[str, Any]							     =			'sample'







    @property
    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_=(32, 32)	)				->     Union[str, Any]:
         __lowerCamelCase   :	Optional[int]								=		4
         __lowerCamelCase   :	int								=		3

         __lowerCamelCase   :	Optional[int]								=		floats_tensor((batch_size, num_channels) + sizes	).to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	str								=		torch.tensor(batch_size * [10]	).to(dtype=torch.intaa			,     device=SCREAMING_SNAKE_CASE_	)

         return {"sample": noise, "timestep": time_step}







    @property
    def       lowercase_				(							self	)				->     Optional[Any]:
         return (3, 32, 32)







    @property
    def       lowercase_				(							self	)				->     Dict:
         return (3, 32, 32)







    def       lowercase_				(							self	)				->     List[str]:
         __lowerCamelCase   :	Optional[Any]								=		{
             'block_out_channels': [32, 64, 64, 64],
             'in_channels': 3,
             'layers_per_block': 1,
             'out_channels': 3,
             'time_embedding_type': 'fourier',
             'norm_eps': 1E-6,
             'mid_block_scale_factor': math.sqrt(2.0	),
             'norm_num_groups': None,
             'down_block_types': [
                 'SkipDownBlock2D',
                 'AttnSkipDownBlock2D',
                 'SkipDownBlock2D',
                 'SkipDownBlock2D',
             ],
             'up_block_types': [
                 'SkipUpBlock2D',
                 'SkipUpBlock2D',
                 'AttnSkipUpBlock2D',
                 'SkipUpBlock2D',
             ],
         }
         __lowerCamelCase   :	int								=		self.dummy_input
         return init_dict, inputs_dict







    @slow
    def       lowercase_				(							self	)				->     List[Any]:
         __lowerCamelCase				,       __lowerCamelCase   :	Union[str, Any]								=		UNetaDModel.from_pretrained('google/ncsnpp-celebahq-256'			,     output_loading_info=SCREAMING_SNAKE_CASE_	)
         self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)
         self.assertEqual(len(loading_info['missing_keys']	)			,     0	)

         model.to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	List[Any]								=		self.dummy_input
         __lowerCamelCase   :	Union[str, Any]								=		floats_tensor((4, 3) + (2_56, 2_56)	).to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	List[Any]								=		noise
         __lowerCamelCase   :	Dict								=		model(**SCREAMING_SNAKE_CASE_	)

         assert image is not None, "Make sure output is not None"







    @slow
    def       lowercase_				(							self	)				->     Tuple:
         __lowerCamelCase   :	Any								=		UNetaDModel.from_pretrained('google/ncsnpp-celebahq-256'	)
         model.to(SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	Any								=		4
         __lowerCamelCase   :	List[str]								=		3
         __lowerCamelCase   :	Optional[Any]								=		(2_56, 2_56)

         __lowerCamelCase   :	Optional[int]								=		torch.ones((batch_size, num_channels) + sizes	).to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Tuple								=		torch.tensor(batch_size * [1E-4]	).to(SCREAMING_SNAKE_CASE_	)

         with torch.no_grad():
              __lowerCamelCase   :	List[str]								=		model(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_	).sample

         __lowerCamelCase   :	Dict								=		output[0, -3:, -3:, -1].flatten().cpu()
         # fmt: off
         __lowerCamelCase   :	List[Any]								=		torch.tensor([-4_8_4_2.8_6_9_1, -6_4_9_9.6_6_3_1, -3_8_0_0.1_9_5_3, -7_9_7_8.2_6_8_6, -1_0_9_8_0.7_1_2_9, -2_0_0_2_8.8_5_3_5, 8_1_4_8.2_8_2_2, 2_3_4_2.2_9_0_5, 5_6_7.7_6_0_8]	)
         # fmt: on

         self.assertTrue(torch_all_close(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     rtol=1E-2	)	)







    def       lowercase_				(							self	)				->     int:
         __lowerCamelCase   :	Dict								=		UNetaDModel.from_pretrained('fusing/ncsnpp-ffhq-ve-dummy-update'	)
         model.to(SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	str								=		4
         __lowerCamelCase   :	Dict								=		3
         __lowerCamelCase   :	Union[str, Any]								=		(32, 32)

         __lowerCamelCase   :	Dict								=		torch.ones((batch_size, num_channels) + sizes	).to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	Optional[Any]								=		torch.tensor(batch_size * [1E-4]	).to(SCREAMING_SNAKE_CASE_	)

         with torch.no_grad():
              __lowerCamelCase   :	Optional[int]								=		model(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_	).sample

         __lowerCamelCase   :	Optional[Any]								=		output[0, -3:, -3:, -1].flatten().cpu()
         # fmt: off
         __lowerCamelCase   :	Optional[Any]								=		torch.tensor([-0.0_3_2_5, -0.0_9_0_0, -0.0_8_6_9, -0.0_3_3_2, -0.0_7_2_5, -0.0_2_7_0, -0.0_1_0_1, 0.0_2_2_7, 0.0_2_5_6]	)
         # fmt: on

         self.assertTrue(torch_all_close(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     rtol=1E-2	)	)







    def       lowercase_				(							self	)				->     Any:
         # not required for this model
         pass










'''simple docstring'''



A__		:					Any												=  8.3_1_4_4_6_2  # Unit - J mol-1 K-1



def 			UpperCAmelCase__					(	UpperCAmelCase_    :				float      ,    UpperCAmelCase_    :				float      ,    UpperCAmelCase_    :				float							)     ->		float:
     if moles < 0 or kelvin < 0 or volume < 0:
          raise ValueError('Invalid inputs. Enter positive value.'							)
     return moles * kelvin * UNIVERSAL_GAS_CONSTANT / volume



def 			UpperCAmelCase__					(	UpperCAmelCase_    :				float      ,    UpperCAmelCase_    :				float      ,    UpperCAmelCase_    :				float							)     ->		float:
     if moles < 0 or kelvin < 0 or pressure < 0:
          raise ValueError('Invalid inputs. Enter positive value.'							)
     return moles * kelvin * UNIVERSAL_GAS_CONSTANT / pressure


if __name__ == "__main__":
      from doctest import testmod

      testmod()






