





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				(    UpperCAmelCase   ,				UpperCAmelCase   ,				unittest.TestCase      ):
		_a     :  Optional[Any]           =     VQModel
		_a     :  int           =     'sample'
		@property
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE=(32, 32)						)			->	List[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      4
									_UpperCAmelCase					=      3

									_UpperCAmelCase					=      floats_tensor((batch_size, num_channels) + sizes						).to(_SCREAMING_SNAKE_CASE						)

									return {"sample": image}
		@property
		def      UpperCAmelCase__    (      self						)			->	Optional[Any]:




									"""simple docstring"""





									return (3, 32, 32)
		@property
		def      UpperCAmelCase__    (      self						)			->	List[Any]:




									"""simple docstring"""





									return (3, 32, 32)
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									_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      UpperCAmelCase__    (      self						)			->	Optional[Any]:




									"""simple docstring"""





									pass
		def      UpperCAmelCase__    (      self						)			->	Any:




									"""simple docstring"""





									pass
		def      UpperCAmelCase__    (      self						)			->	Dict:




									"""simple docstring"""





									_UpperCAmelCase		,	_UpperCAmelCase					=      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						)
									_UpperCAmelCase					=      model(**self.dummy_input						)

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






		def      UpperCAmelCase__    (      self						)			->	Union[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      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						)

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

									_UpperCAmelCase					=      output[0, -1, -3:, -3:].flatten().cpu()
									# fmt: off
									_UpperCAmelCase					=      torch.tensor([-0.0153, -0.4044, -0.1880, -0.5161, -0.2418, -0.4072, -0.1612, -0.0633, -0.0143]						)
									# fmt: on
									self.assertTrue(torch.allclose(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   atol=1e-3						)						)




def 	lowerCAmelCase__			(      a__:		int	)  ->		None:


							'''simple docstring'''





							_UpperCAmelCase					=      generate_pascal_triangle(a__	)
							for row_idx in range(a__	):
														# Print left spaces
														for _ in range(num_rows - row_idx - 1	):
																					print(end=' '	)
														# Print row values
														for col_idx in range(row_idx + 1	):
																					if col_idx != row_idx:
																												print(triangle[row_idx][col_idx]      ,  end=' '	)
																					else:
																												print(triangle[row_idx][col_idx]      ,  end=''	)
														print()

def 	lowerCAmelCase__			(      a__:		int	)  ->		list[list[int]]:


							'''simple docstring'''





							if not isinstance(a__      ,  a__	):
														raise TypeError('The input value of \'num_rows\' should be \'int\''	)

							if num_rows == 0:
														return []
							elif num_rows < 0:
														raise ValueError(
														    'The input value of \'num_rows\' should be greater than or equal to 0'	)

							_UpperCAmelCase					=      []
							for current_row_idx in range(a__	):
														_UpperCAmelCase					=      populate_current_row(a__      ,  a__	)
														triangle.append(a__	)
							return triangle

def 	lowerCAmelCase__			(      a__:		list[list[int]]      ,  a__:		int	)  ->		list[int]:


							'''simple docstring'''





							_UpperCAmelCase					=      [-1] * (current_row_idx + 1)
							# first and last elements of current row are equal to 1
							_UpperCAmelCase		,	_UpperCAmelCase					=      1, 1
							for current_col_idx in range(1      ,  a__	):
														calculate_current_element(
														    a__      ,  a__      ,  a__      ,  a__	)
							return current_row

def 	lowerCAmelCase__			(      a__:		list[list[int]]      ,  a__:		list[int]      ,  a__:		int      ,  a__:		int      ,  )  ->		None:


							'''simple docstring'''





							_UpperCAmelCase					=      triangle[current_row_idx - 1][current_col_idx - 1]
							_UpperCAmelCase					=      triangle[current_row_idx - 1][current_col_idx]
							_UpperCAmelCase					=      above_to_left_elt + above_to_right_elt

def 	lowerCAmelCase__			(      a__:		int	)  ->		list[list[int]]:


							'''simple docstring'''





							if not isinstance(a__      ,  a__	):
														raise TypeError('The input value of \'num_rows\' should be \'int\''	)

							if num_rows == 0:
														return []
							elif num_rows < 0:
														raise ValueError(
														    'The input value of \'num_rows\' should be greater than or equal to 0'	)

							_UpperCAmelCase					=      [[1]]

							for row_index in range(1      ,  a__	):
														_UpperCAmelCase					=      [0] + result[-1] + [0]
														_UpperCAmelCase					=      row_index + 1
														# Calculate the number of distinct elements in a row
														_UpperCAmelCase					=      sum(divmod(a__      ,  2	)	)
														_UpperCAmelCase					=      [
														    temp_row[i - 1] + temp_row[i] for i in range(1      ,  distinct_elements + 1	)
														]
														_UpperCAmelCase					=      row_first_half[: (row_index + 1) // 2]
														row_second_half.reverse()
														_UpperCAmelCase					=      row_first_half + row_second_half
														result.append(a__	)

							return result

def 	lowerCAmelCase__			(      )  ->		None:


							'''simple docstring'''





							from collections.abc import Callable
							from timeit import timeit

							def benchmark_a_function(a__:		Callable      ,  a__:		int	) -> None:
														_UpperCAmelCase					=      F'''{func.__name__}({value})'''
														_UpperCAmelCase					=      timeit(F'''__main__.{call}'''      ,  setup='import __main__'	)
														# print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
														print(F'''{call:38} -- {timing:.4f} seconds'''	)

							for value in range(1_5	):  # (1, 7, 14):
														for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
																					benchmark_a_function(a__      ,  a__	)
														print()


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		benchmark()
