






'''simple docstring'''



import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()
class UpperCAmelCase_       (     __A					,							__A					,							unittest.TestCase					):




      """simple docstring"""




      UpperCamelCase_             =      VQModel
      UpperCamelCase_             =      '''sample'''






      @property
      def 					A__   (			self      :		Optional[Any]  ,   UpperCAmelCase      :		Any=(32, 32)		)	->	str:


       '''simple docstring'''

       lowercase       : List[Any]						=4
       lowercase       : Any						=3

       lowercase       : Optional[Any]						=floats_tensor((batch_size, num_channels) + sizes		).to(UpperCAmelCase		)

       return {"sample": image}






      @property
      def 					A__   (			self      :		Optional[int]		)	->	Optional[int]:


       '''simple docstring'''

       return (3, 32, 32)






      @property
      def 					A__   (			self      :		Any		)	->	int:


       '''simple docstring'''

       return (3, 32, 32)






      def 					A__   (			self      :		str		)	->	Optional[int]:


       '''simple docstring'''

       lowercase       : int						={
           '''block_out_channels''': [32, 64],
           '''in_channels''': 3,
           '''out_channels''': 3,
           '''down_block_types''': ['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],
           '''up_block_types''': ['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],
           '''latent_channels''': 3,
       }
       lowercase       : List[Any]						=self.dummy_input
       return init_dict, inputs_dict






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


       '''simple docstring'''

       pass






      def 					A__   (			self      :		Dict		)	->	List[Any]:


       '''simple docstring'''

       pass






      def 					A__   (			self      :		str		)	->	Any:


       '''simple docstring'''

       lowercase	,		lowercase       : List[Any]						=VQModel.from_pretrained('''fusing/vqgan-dummy'''  ,   output_loading_info=UpperCAmelCase		)
       self.assertIsNotNone(UpperCAmelCase		)
       self.assertEqual(len(loading_info['''missing_keys''']		)  ,   0		)

       model.to(UpperCAmelCase		)
       lowercase       : Dict						=model(**self.dummy_input		)

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






      def 					A__   (			self      :		Dict		)	->	Any:


       '''simple docstring'''

       lowercase       : Optional[int]						=VQModel.from_pretrained('''fusing/vqgan-dummy'''		)
       model.to(UpperCAmelCase		).eval()

       torch.manual_seed(0		)
       if torch.cuda.is_available():
        torch.cuda.manual_seed_all(0		)

       lowercase       : Any						=torch.randn(1  ,   model.config.in_channels  ,   model.config.sample_size  ,   model.config.sample_size		)
       lowercase       : int						=image.to(UpperCAmelCase		)
       with torch.no_grad():
        lowercase       : List[str]						=model(UpperCAmelCase		).sample

       lowercase       : Dict						=output[0, -1, -3:, -3:].flatten().cpu()
       # fmt: off
       lowercase       : List[Any]						=torch.tensor([-0.0_1_5_3, -0.4_0_4_4, -0.1_8_8_0, -0.5_1_6_1, -0.2_4_1_8, -0.4_0_7_2, -0.1_6_1_2, -0.0_6_3_3, -0.0_1_4_3]		)
       # fmt: on
       self.assertTrue(torch.allclose(UpperCAmelCase  ,   UpperCAmelCase  ,   atol=1e-3		)		)










__lowerCamelCase			:	Any					    =	9.8_0_6_6_5



def 						A_							(	_lowerCAmelCase				,  _lowerCAmelCase				,  _lowerCAmelCase = g	)		->					float:

 if fluid_density <= 0:
  raise ValueError("Impossible fluid density"	)
 if volume < 0:
  raise ValueError("Impossible Object volume"	)
 if gravity <= 0:
  raise ValueError("Impossible Gravity"	)

 return fluid_density * gravity * volume


if __name__ == "__main__":
    import doctest

    # run doctest
    doctest.testmod()
