






"""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     (     UpperCamelCase   ,     UpperCamelCase   ,     unittest.TestCase						):
					lowercase_    :				List[Any]      =  VQModel
					lowercase_    :				Any      =  """sample"""
					@property
					def        UpperCAmelCase__ (							self							:	str     , UpperCAmelCase							:	Union[str, Any]=(32, 32)   )	->       Tuple:
											lowerCAmelCase   :Dict						=			4
											lowerCAmelCase   :str						=			3

											lowerCAmelCase   :Any						=			floats_tensor((batch_size, num_channels) + sizes   ).to(UpperCAmelCase   )

											return {"sample": image}
					@property
					def        UpperCAmelCase__ (							self							:	Optional[Any]   )	->       Tuple:
											return (3, 32, 32)
					@property
					def        UpperCAmelCase__ (							self							:	str   )	->       Optional[Any]:
											return (3, 32, 32)
					def        UpperCAmelCase__ (							self							:	List[Any]   )	->       Dict:
											lowerCAmelCase   :Dict						=			{
											    'block_out_channels': [32, 64],
											    'in_channels': 3,
											    'out_channels': 3,
											    'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
											    'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
											    'latent_channels': 3,
											}
											lowerCAmelCase   :Optional[int]						=			self.dummy_input
											return init_dict, inputs_dict
					def        UpperCAmelCase__ (							self							:	Tuple   )	->       List[Any]:
											pass
					def        UpperCAmelCase__ (							self							:	str   )	->       List[Any]:
											pass
					def        UpperCAmelCase__ (							self							:	int   )	->       Any:
											lowerCAmelCase	, lowerCAmelCase   :List[Any]						=			VQModel.from_pretrained('fusing/vqgan-dummy'     , output_loading_info=UpperCAmelCase   )
											self.assertIsNotNone(UpperCAmelCase   )
											self.assertEqual(len(loading_info['missing_keys']   )     , 0   )

											model.to(UpperCAmelCase   )
											lowerCAmelCase   :Optional[int]						=			model(**self.dummy_input   )

											assert image is not None, "Make sure output is not None"
					def        UpperCAmelCase__ (							self							:	str   )	->       Union[str, Any]:
											lowerCAmelCase   :List[Any]						=			VQModel.from_pretrained('fusing/vqgan-dummy'   )
											model.to(UpperCAmelCase   ).eval()

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

											lowerCAmelCase   :Union[str, Any]						=			torch.randn(1     , model.config.in_channels     , model.config.sample_size     , model.config.sample_size   )
											lowerCAmelCase   :Optional[Any]						=			image.to(UpperCAmelCase   )
											with torch.no_grad():
																	lowerCAmelCase   :Any						=			model(UpperCAmelCase   ).sample

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







"""simple docstring"""


def        UpperCAmelCase      (					a__     ,      a__ ):





						'''simple docstring'''






						lowerCAmelCase   :Tuple						=			len(a__ )
						print('The following activities are selected:' )

						# The first activity is always selected
						lowerCAmelCase   :Dict						=			0
						print(a__     ,      end=',' )

						# Consider rest of the activities
						for j in range(a__ ):
												# If this activity has start time greater than
												# or equal to the finish time of previously
												# selected activity, then select it
												if start[j] >= finish[i]:
																		print(a__     ,      end=',' )
																		lowerCAmelCase   :List[str]						=			j


if __name__ == "__main__":
		import doctest

		doctest.testmod()

		__SCREAMING_SNAKE_CASE   =   [1, 3, 0, 5, 8, 5]
		__SCREAMING_SNAKE_CASE   =   [2, 4, 6, 7, 9, 9]
		print_max_activities(start, finish)