"""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        snake_case (				UpperCamelCase_   ,					UpperCamelCase_   ,					unittest.TestCase       ):




					"""simple docstring"""

					snake_case__       					=				VQModel
					snake_case__       					=				"sample"







					@property
					def 	__lowerCAmelCase		(       self     :			List[str]					,lowerCamelCase__     :			Optional[Any]=(32, 32)    ):
									UpperCAmelCase__    =							4
									UpperCAmelCase__    =							3

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

									return {"sample": image}







					@property
					def 	__lowerCAmelCase		(       self     :			str    ):
									return (3, 32, 32)







					@property
					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									return (3, 32, 32)







					def 	__lowerCAmelCase		(       self     :			str    ):
									UpperCAmelCase__    =							{
									    'block_out_channels': [32, 64],
									    '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 	__lowerCAmelCase		(       self     :			Union[str, Any]    ):
									pass







					def 	__lowerCAmelCase		(       self     :			List[str]    ):
									pass







					def 	__lowerCAmelCase		(       self     :			str    ):
									UpperCAmelCase__    =							VQModel.from_pretrained('fusing/vqgan-dummy'					,output_loading_info=__a    )
									self.assertIsNotNone(__a    )
									self.assertEqual(len(loading_info['missing_keys']    )					,0    )

									model.to(__a    )
									UpperCAmelCase__    =							model(**self.dummy_input    )

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







					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									UpperCAmelCase__    =							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    )

									UpperCAmelCase__    =							torch.randn(1					,model.config.in_channels					,model.config.sample_size					,model.config.sample_size    )
									UpperCAmelCase__    =							image.to(__a    )
									with torch.no_grad():
													UpperCAmelCase__    =							model(__a    ).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(__a					,__a					,atol=1e-3    )    )



"""simple docstring"""






import warnings
from functools import wraps
from typing import Callable



def 						a_		(      lowerCamelCase ):

				@wraps(lowerCamelCase )
				def _inner_fn(*lowerCamelCase      ,    **lowerCamelCase ):
								warnings.warn(
								    (f'''\'{fn.__name__}\' is experimental and might be subject to breaking changes in the future.''')      ,    lowerCamelCase      ,    )
								return fn(*lowerCamelCase      ,    **lowerCamelCase )

				return _inner_fn



