




'''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							(		a__   ,   a__   ,   unittest.TestCase				):
     SCREAMING_SNAKE_CASE_				:       Optional[Any]       							=		VQModel
     SCREAMING_SNAKE_CASE_				:       Tuple       							=		"""sample"""






     @property
     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE=(32, 32)       )				->     Dict:
          _snake_case				= 4
          _snake_case				= 3

          _snake_case				= floats_tensor((batch_size, num_channels) + sizes       ).to(__a       )

          return {"sample": image}






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






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






     def 							_lowercase      (					self       )				->     str:
          _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,
          }
          _snake_case				= self.dummy_input
          return init_dict, inputs_dict






     def 							_lowercase      (					self       )				->     Dict:
          pass






     def 							_lowercase      (					self       )				->     Any:
          pass






     def 							_lowercase      (					self       )				->     int:
          _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       )
          _snake_case				= model(**self.dummy_input       )

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






     def 							_lowercase      (					self       )				->     List[str]:
          _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       )

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

          _snake_case				= output[0, -1, -3:, -3:].flatten().cpu()
          # fmt: off
          _snake_case				= 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(__a   ,__a   ,atol=1e-3       )       )








'''simple docstring'''







def        lowerCamelCase__				(      __lowercase				):
     if not isinstance(__lowercase     ,   __lowercase				):
          snake_case			:      int        =			F'''Input value of [number={number}] must be an integer'''
          raise TypeError(__lowercase				)
     if number < 0:
          return False
     snake_case			:      Optional[int]        =			number * number
     while number > 0:
          if number % 10 != number_square % 10:
               return False
          number //= 10
          number_square //= 10
     return True


if __name__ == "__main__":
      import doctest

      doctest.testmod()



