




"""simple docstring"""

import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()
class     A__      (      unittest.TestCase     ):




 @property
 def 							a_		(   self  :	Dict	)					-> Tuple:
      __snake_case          =	1
      __snake_case          =	3
      __snake_case          =	(32, 32)

      __snake_case          =	floats_tensor((batch_size, num_channels) + sizes      ,    rng=random.Random(0	)	).to(lowercase	)
      return image




 @property
 def 							a_		(   self  :	Union[str, Any]	)					-> List[str]:
      torch.manual_seed(0	)
      __snake_case          =	UNetaDModel(
          block_out_channels=(32, 64)      ,    layers_per_block=2      ,    sample_size=32      ,    in_channels=6      ,    out_channels=3      ,    down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")      ,    up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")      ,    )
      return model




 @property
 def 							a_		(   self  :	int	)					-> str:
      torch.manual_seed(0	)
      __snake_case          =	VQModel(
          block_out_channels=[32, 64]      ,    in_channels=3      ,    out_channels=3      ,    down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]      ,    up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]      ,    latent_channels=3      ,    )
      return model




 def 							a_		(   self  :	Union[str, Any]	)					-> Union[str, Any]:
      __snake_case          =	"""cpu"""
      __snake_case          =	self.dummy_uncond_unet
      __snake_case          =	DDIMScheduler()
      __snake_case          =	self.dummy_vq_model

      __snake_case          =	LDMSuperResolutionPipeline(unet=lowercase      ,    vqvae=lowercase      ,    scheduler=lowercase	)
      ldm.to(lowercase	)
      ldm.set_progress_bar_config(disable=lowercase	)

      __snake_case          =	self.dummy_image.to(lowercase	)

      __snake_case          =	torch.Generator(device=lowercase	).manual_seed(0	)
      __snake_case          =	ldm(image=lowercase      ,    generator=lowercase      ,    num_inference_steps=2      ,    output_type="""numpy"""	).images

      __snake_case          =	image[0, -3:, -3:, -1]

      assert image.shape == (1, 64, 64, 3)
      __snake_case          =	np.array([0.86_78, 0.82_45, 0.63_81, 0.68_30, 0.43_85, 0.55_99, 0.46_41, 0.62_01, 0.51_50]	)

      assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2




 @unittest.skipIf(torch_device != """cuda"""      ,    """This test requires a GPU"""	)
 def 							a_		(   self  :	Any	)					-> List[Any]:
      __snake_case          =	self.dummy_uncond_unet
      __snake_case          =	DDIMScheduler()
      __snake_case          =	self.dummy_vq_model

      # put models in fp16
      __snake_case          =	unet.half()
      __snake_case          =	vqvae.half()

      __snake_case          =	LDMSuperResolutionPipeline(unet=lowercase      ,    vqvae=lowercase      ,    scheduler=lowercase	)
      ldm.to(lowercase	)
      ldm.set_progress_bar_config(disable=lowercase	)

      __snake_case          =	self.dummy_image.to(lowercase	)

      __snake_case          =	ldm(lowercase      ,    num_inference_steps=2      ,    output_type="""numpy"""	).images

      assert image.shape == (1, 64, 64, 3)

@slow
@require_torch
class     A__      (      unittest.TestCase     ):




 def 							a_		(   self  :	List[str]	)					-> Union[str, Any]:
      __snake_case          =	load_image(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
          """/vq_diffusion/teddy_bear_pool.png"""	)
      __snake_case          =	init_image.resize((64, 64)      ,    resample=PIL_INTERPOLATION["""lanczos"""]	)

      __snake_case          =	LDMSuperResolutionPipeline.from_pretrained("""duongna/ldm-super-resolution"""      ,    device_map="""auto"""	)
      ldm.set_progress_bar_config(disable=lowercase	)

      __snake_case          =	torch.manual_seed(0	)
      __snake_case          =	ldm(image=lowercase      ,    generator=lowercase      ,    num_inference_steps=20      ,    output_type="""numpy"""	).images

      __snake_case          =	image[0, -3:, -3:, -1]

      assert image.shape == (1, 256, 256, 3)
      __snake_case          =	np.array([0.76_44, 0.76_79, 0.76_42, 0.76_33, 0.76_66, 0.75_60, 0.74_25, 0.72_57, 0.69_07]	)

      assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2








"""simple docstring"""

from itertools import combinations_with_replacement




def       snake_case__	(       lowerCAmelCase   :		int = 100		):
					__snake_case          =	[*list(range(1				,					21		)		), 25]
					__snake_case          =	[2 * x for x in range(1				,					21		)] + [50]
					__snake_case          =	[3 * x for x in range(1				,					21		)]
					__snake_case          =	singles + doubles + triples + [0]

					__snake_case          =	0
					__snake_case          =	42
					__snake_case          =	42
					__snake_case          =	42
					__snake_case          =	42

					for double in doubles:
										for throwa, throwa in combinations_with_replacement(lowerCAmelCase				,					2		):
															__snake_case          =	double + throwa + throwa
															if checkout_total < limit:
																				num_checkouts += 1

					return num_checkouts


if __name__ == "__main__":
		print(f'{solution() = }')


