

'''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 							A__   (	__SCREAMING_SNAKE_CASE					,       __SCREAMING_SNAKE_CASE					,       unittest.TestCase  ):
  A__					=    VQModel
  A__					=    'sample'





  @property
  def 						A  (		self				:     int							, _a				:     List[Any]=(32, 32)			)     ->   Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =4
       _SCREAMING_SNAKE_CASE							   =3

       _SCREAMING_SNAKE_CASE							   =floats_tensor((batch_size, num_channels) + sizes			).to(_a			)

       return {"sample": image}





  @property
  def 						A  (		self				:     List[Any]			)     ->   Optional[int]:





       '''simple docstring'''






       return (3, 32, 32)





  @property
  def 						A  (		self				:     int			)     ->   int:





       '''simple docstring'''






       return (3, 32, 32)





  def 						A  (		self				:     Tuple			)     ->   int:





       '''simple docstring'''






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





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





       '''simple docstring'''






       pass





  def 						A  (		self				:     Any			)     ->   Any:





       '''simple docstring'''






       pass





  def 						A  (		self				:     Optional[int]			)     ->   Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE							   =VQModel.from_pretrained('fusing/vqgan-dummy'							, output_loading_info=_a			)
       self.assertIsNotNone(_a			)
       self.assertEqual(len(loading_info['missing_keys']			)							, 0			)

       model.to(_a			)
       _SCREAMING_SNAKE_CASE							   =model(**self.dummy_input			)

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





  def 						A  (		self				:     str			)     ->   str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =VQModel.from_pretrained('fusing/vqgan-dummy'			)
       model.to(_a			).eval()

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

       _SCREAMING_SNAKE_CASE							   =torch.randn(1							, model.config.in_channels							, model.config.sample_size							, model.config.sample_size			)
       _SCREAMING_SNAKE_CASE							   =image.to(_a			)
       with torch.no_grad():
            _SCREAMING_SNAKE_CASE							   =model(_a			).sample

       _SCREAMING_SNAKE_CASE							   =output[0, -1, -3:, -3:].flatten().cpu()
       # fmt: off
       _SCREAMING_SNAKE_CASE							   =torch.tensor([-0.01_53, -0.40_44, -0.18_80, -0.51_61, -0.24_18, -0.40_72, -0.16_12, -0.06_33, -0.01_43]			)
       # fmt: on
       self.assertTrue(torch.allclose(_a							, _a							, atol=1e-3			)			)



'''simple docstring'''
def 	_lowerCAmelCase (						_UpperCamelCase						:					float							,			_UpperCamelCase						:					float    )				->      float:
     """simple docstring"""




     if mass < 0:
          raise ValueError('The mass of a body cannot be negative'    )
     return 0.5 * mass * abs(_UpperCamelCase    ) * abs(_UpperCamelCase    )


if __name__ == "__main__":
     import doctest

     doctest.testmod(verbose=True)
