




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      ,     SCREAMING_SNAKE_CASE=(32, 32)      )  ->					Optional[int]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						4
				SCREAMING_SNAKE_CASE_								=						3

				SCREAMING_SNAKE_CASE_								=						floats_tensor((batch_size, num_channels) + sizes      ).to(SCREAMING_SNAKE_CASE      )

				return {"sample": image}





	@property
	def 						A_(							self      )  ->					List[Any]:




				"""simple docstring"""



				return (3, 32, 32)





	@property
	def 						A_(							self      )  ->					List[Any]:




				"""simple docstring"""



				return (3, 32, 32)





	def 						A_(							self      )  ->					str:




				"""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      )  ->					int:




				"""simple docstring"""



				pass





	def 						A_(							self      )  ->					List[str]:




				"""simple docstring"""



				pass





	def 						A_(							self      )  ->					Dict:




				"""simple docstring"""



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

				model.to(SCREAMING_SNAKE_CASE      )
				SCREAMING_SNAKE_CASE_								=						model(**self.dummy_input      )

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





	def 						A_(							self      )  ->					Optional[int]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						VQModel.from_pretrained('fusing/vqgan-dummy'      )
				model.to(SCREAMING_SNAKE_CASE      ).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(SCREAMING_SNAKE_CASE      )
				with torch.no_grad():
							SCREAMING_SNAKE_CASE_								=						model(SCREAMING_SNAKE_CASE      ).sample

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






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


SCREAMING_SNAKE_CASE__     :     str		    =       {
    "configuration_altclip": [
        "ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "AltCLIPConfig",
        "AltCLIPTextConfig",
        "AltCLIPVisionConfig",
    ],
    "processing_altclip": ["AltCLIPProcessor"],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				SCREAMING_SNAKE_CASE__     :     Any		    =       [
				    "ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "AltCLIPPreTrainedModel",
				    "AltCLIPModel",
				    "AltCLIPTextModel",
				    "AltCLIPVisionModel",
				]


if TYPE_CHECKING:
				from .configuration_altclip import (
				    ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    AltCLIPConfig,
				    AltCLIPTextConfig,
				    AltCLIPVisionConfig,
				)
				from .processing_altclip import AltCLIPProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_altclip import (
								    ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
								    AltCLIPModel,
								    AltCLIPPreTrainedModel,
								    AltCLIPTextModel,
								    AltCLIPVisionModel,
								)


else:
				import sys

				SCREAMING_SNAKE_CASE__     :     Tuple		    =       _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
