


"""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  lowercase_  ( unittest.TestCase						):







      @property
      def 				_lowerCAmelCase       (      self :							List[Any]    ):
        lowerCAmelCase__    :    str								=					1
        lowerCAmelCase__    :    Any								=					3
        lowerCAmelCase__    :    str								=					(3_2, 3_2)

        lowerCAmelCase__    :    int								=					floats_tensor((batch_size, num_channels) + sizes		,  rng=random.Random(0    )    ).to(_lowercase    )
        return image







      @property
      def 				_lowerCAmelCase       (      self :							Tuple    ):
        torch.manual_seed(0    )
        lowerCAmelCase__    :    int								=					UNetaDModel(
            block_out_channels=(3_2, 6_4)		,  layers_per_block=2		,  sample_size=3_2		,  in_channels=6		,  out_channels=3		,  down_block_types=("DownBlock2D", "AttnDownBlock2D")		,  up_block_types=("AttnUpBlock2D", "UpBlock2D")		,  )
        return model







      @property
      def 				_lowerCAmelCase       (      self :							List[Any]    ):
        torch.manual_seed(0    )
        lowerCAmelCase__    :    Union[str, Any]								=					VQModel(
            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		,  )
        return model







      def 				_lowerCAmelCase       (      self :							Union[str, Any]    ):
        lowerCAmelCase__    :    int								=					"cpu"
        lowerCAmelCase__    :    int								=					self.dummy_uncond_unet
        lowerCAmelCase__    :    Optional[Any]								=					DDIMScheduler()
        lowerCAmelCase__    :    Optional[Any]								=					self.dummy_vq_model

        lowerCAmelCase__    :    Union[str, Any]								=					LDMSuperResolutionPipeline(unet=_lowercase		,  vqvae=_lowercase		,  scheduler=_lowercase    )
        ldm.to(_lowercase    )
        ldm.set_progress_bar_config(disable=_lowercase    )

        lowerCAmelCase__    :    int								=					self.dummy_image.to(_lowercase    )

        lowerCAmelCase__    :    Optional[int]								=					torch.Generator(device=_lowercase    ).manual_seed(0    )
        lowerCAmelCase__    :    List[str]								=					ldm(image=_lowercase		,  generator=_lowercase		,  num_inference_steps=2		,  output_type="numpy"    ).images

        lowerCAmelCase__    :    int								=					image[0, -3:, -3:, -1]

        assert image.shape == (1, 6_4, 6_4, 3)
        lowerCAmelCase__    :    str								=					np.array([0.8678, 0.8245, 0.6381, 0.6830, 0.4385, 0.5599, 0.4641, 0.6201, 0.5150]    )

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







      @unittest.skipIf(torch_device != "cuda"		,  "This test requires a GPU"    )
      def 				_lowerCAmelCase       (      self :							Optional[int]    ):
        lowerCAmelCase__    :    Optional[int]								=					self.dummy_uncond_unet
        lowerCAmelCase__    :    str								=					DDIMScheduler()
        lowerCAmelCase__    :    Any								=					self.dummy_vq_model

        # put models in fp16
        lowerCAmelCase__    :    Optional[int]								=					unet.half()
        lowerCAmelCase__    :    int								=					vqvae.half()

        lowerCAmelCase__    :    int								=					LDMSuperResolutionPipeline(unet=_lowercase		,  vqvae=_lowercase		,  scheduler=_lowercase    )
        ldm.to(_lowercase    )
        ldm.set_progress_bar_config(disable=_lowercase    )

        lowerCAmelCase__    :    Optional[int]								=					self.dummy_image.to(_lowercase    )

        lowerCAmelCase__    :    Union[str, Any]								=					ldm(_lowercase		,  num_inference_steps=2		,  output_type="numpy"    ).images

        assert image.shape == (1, 6_4, 6_4, 3)

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







      def 				_lowerCAmelCase       (      self :							Tuple    ):
        lowerCAmelCase__    :    Union[str, Any]								=					load_image(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
            "/vq_diffusion/teddy_bear_pool.png"    )
        lowerCAmelCase__    :    Dict								=					init_image.resize((6_4, 6_4)		,  resample=PIL_INTERPOLATION["lanczos"]    )

        lowerCAmelCase__    :    Tuple								=					LDMSuperResolutionPipeline.from_pretrained("duongna/ldm-super-resolution"		,  device_map="auto"    )
        ldm.set_progress_bar_config(disable=_lowercase    )

        lowerCAmelCase__    :    Any								=					torch.manual_seed(0    )
        lowerCAmelCase__    :    str								=					ldm(image=_lowercase		,  generator=_lowercase		,  num_inference_steps=2_0		,  output_type="numpy"    ).images

        lowerCAmelCase__    :    Any								=					image[0, -3:, -3:, -1]

        assert image.shape == (1, 2_5_6, 2_5_6, 3)
        lowerCAmelCase__    :    Union[str, Any]								=					np.array([0.7644, 0.7679, 0.7642, 0.7633, 0.7666, 0.7560, 0.7425, 0.7257, 0.6907]    )

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




"""simple docstring"""





from math import factorial





def     lowercase__	(  lowerCamelCase     :  Dict				,	lowerCamelCase     :  int				)					->     Tuple:
  return factorial(lowerCamelCase				) / (factorial(lowerCamelCase				) * factorial(n - r				))





def     lowercase__	(  )					->     Optional[Any]:
  lowerCAmelCase__    :    List[Any]								=					0

  for i in range(1				,	1_0_1				):
    for j in range(1				,	i + 1				):
      if combinations(lowerCamelCase				,	lowerCamelCase				) > 1e6:
        total += 1
  return total


if __name__ == "__main__":
   print(solution())
