
"""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							(		SCREAMING_SNAKE_CASE_     ,			SCREAMING_SNAKE_CASE_     ,			unittest.TestCase							):
						__SCREAMING_SNAKE_CASE   :							List[str]							      =	VQModel
						__SCREAMING_SNAKE_CASE   :							int							      =	"sample"




						@property
						def     a_      (							self   ,       lowercase_=(3_2, 3_2)							)						->					List[str]:
										UpperCAmelCase									=					4
										UpperCAmelCase									=					3

										UpperCAmelCase									=					floats_tensor((batch_size, num_channels) + sizes							).to(lowercase_							)

										return {"sample": image}




						@property
						def     a_      (							self							)						->					Optional[int]:
										return (3, 3_2, 3_2)




						@property
						def     a_      (							self							)						->					Union[str, Any]:
										return (3, 3_2, 3_2)




						def     a_      (							self							)						->					Tuple:
										UpperCAmelCase									=					{
										    'block_out_channels': [3_2, 6_4],
										    'in_channels': 3,
										    'out_channels': 3,
										    'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
										    'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
										    'latent_channels': 3,
										}
										UpperCAmelCase									=					self.dummy_input
										return init_dict, inputs_dict




						def     a_      (							self							)						->					List[Any]:
										pass




						def     a_      (							self							)						->					Optional[int]:
										pass




						def     a_      (							self							)						->					List[str]:
										UpperCAmelCase			,							UpperCAmelCase									=					VQModel.from_pretrained('fusing/vqgan-dummy'   ,       output_loading_info=lowercase_							)
										self.assertIsNotNone(lowercase_							)
										self.assertEqual(len(loading_info['missing_keys']							)   ,       0							)

										model.to(lowercase_							)
										UpperCAmelCase									=					model(**self.dummy_input							)

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




						def     a_      (							self							)						->					Optional[Any]:
										UpperCAmelCase									=					VQModel.from_pretrained('fusing/vqgan-dummy'							)
										model.to(lowercase_							).eval()

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

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

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





"""simple docstring"""

from abc import ABC, abstractmethod
from argparse import ArgumentParser
class      _UpperCAmelCase							(		SCREAMING_SNAKE_CASE_							):




      @staticmethod
      @abstractmethod
      def     a_      (							lowercase_							)						->					Optional[Any]:
          raise NotImplementedError()




      @abstractmethod
      def     a_      (							self							)						->					Any:
          raise NotImplementedError()



