






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 							SCREAMING_SNAKE_CASE__						(    UpperCamelCase_			,       UpperCamelCase_			,       unittest.TestCase						):
					a_     =		VQModel
					a_     =		"sample"



					@property
					def 	_lowercase					( self					:  str							,		__A					:  List[Any]=(3_2, 3_2)	):
						snake_case__			:				Union[str, Any]       =  4
						snake_case__			:				List[Any]       =  3

						snake_case__			:				Union[str, Any]       =  floats_tensor((batch_size, num_channels) + sizes	).to(__A	)

						return {"sample": image}



					@property
					def 	_lowercase					( self					:  List[str]	):
						return (3, 3_2, 3_2)



					@property
					def 	_lowercase					( self					:  List[Any]	):
						return (3, 3_2, 3_2)



					def 	_lowercase					( self					:  Optional[int]	):
						snake_case__			:				Dict       =  {
						    "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,
						}
						snake_case__			:				List[str]       =  self.dummy_input
						return init_dict, inputs_dict



					def 	_lowercase					( self					:  str	):
						pass



					def 	_lowercase					( self					:  Optional[int]	):
						pass



					def 	_lowercase					( self					:  Any	):
						snake_case__			:				str       =  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__			:				Dict       =  model(**self.dummy_input	)

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






					def 	_lowercase					( self					:  Dict	):
						snake_case__			:				List[Any]       =  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__			:				List[Any]       =  torch.randn(1							,		model.config.in_channels							,		model.config.sample_size							,		model.config.sample_size	)
						snake_case__			:				Any       =  image.to(__A	)
						with torch.no_grad():
							snake_case__			:				Dict       =  model(__A	).sample

						snake_case__			:				Any       =  output[0, -1, -3:, -3:].flatten().cpu()
						# fmt: off
						snake_case__			:				int       =  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	)	)











__lowerCamelCase :      Optional[int]										=				"""Tobias Carryer"""

from time import time



class 							SCREAMING_SNAKE_CASE__						:





					"""simple docstring"""






					def __init__( self					:  List[Any]							,		__A					:  List[Any]							,		__A					:  Optional[int]							,		__A					:  List[str]							,		__A					:  Dict=int(time()	)	):  # noqa: B008
						snake_case__			:				List[Any]       =  multiplier
						snake_case__			:				Optional[int]       =  increment
						snake_case__			:				Optional[int]       =  modulo
						snake_case__			:				Union[str, Any]       =  seed






					def 	_lowercase					( self					:  str	):
						snake_case__			:				Union[str, Any]       =  (self.multiplier * self.seed + self.increment) % self.modulo
						return self.seed


if __name__ == "__main__":
	# Show the LCG in action.
	__lowerCamelCase :      int										=				LinearCongruentialGenerator(166_4525, 10_1390_4223, 2 << 31)
	while True:
		print(lcg.next_number())



