
import os
import string
import sys


a__							:	Dict  						=			1 << 8

a__							:	Any  						=			{
    '''tab''': ord('''\t'''),
    '''newline''': ord('''\r'''),
    '''esc''': 27,
    '''up''': 65 + ARROW_KEY_FLAG,
    '''down''': 66 + ARROW_KEY_FLAG,
    '''right''': 67 + ARROW_KEY_FLAG,
    '''left''': 68 + ARROW_KEY_FLAG,
    '''mod_int''': 91,
    '''undefined''': sys.maxsize,
    '''interrupt''': 3,
    '''insert''': 50,
    '''delete''': 51,
    '''pg_up''': 53,
    '''pg_down''': 54,
}

a__							:	Optional[Any]  						=			KEYMAP['''up''']
a__							:	Any  						=			KEYMAP['''left''']

if sys.platform == "win32":
      a__							:	Any  						=			[]
      a__							:	Optional[Any]  						=			{
          B'''\xe0H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
          B'''\x00H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
          B'''\xe0P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
          B'''\x00P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
          B'''\xe0M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
          B'''\x00M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
          B'''\xe0K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
          B'''\x00K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
      }

for i in range(10):
      a__							:	List[str]  						=			ord(str(i))







def 							UpperCAmelCase_(  ):



    """simple docstring"""



    if os.name == "nt":
        import msvcrt

        SCREAMING_SNAKE_CASE							:							Dict								=      '''mbcs'''
        # Flush the keyboard buffer
        while msvcrt.kbhit():
            msvcrt.getch()
        if len(_A					) == 0:
            # Read the keystroke
            SCREAMING_SNAKE_CASE							:							List[str]								=      msvcrt.getch()

            # If it is a prefix char, get second part
            if ch in (b"\x00", b"\xe0"):
                SCREAMING_SNAKE_CASE							:							Optional[Any]								=      ch + msvcrt.getch()
                # Translate actual Win chars to bullet char types
                try:
                    SCREAMING_SNAKE_CASE							:							Optional[Any]								=      chr(WIN_KEYMAP[cha]					)
                    WIN_CH_BUFFER.append(chr(KEYMAP['''mod_int''']					)					)
                    WIN_CH_BUFFER.append(_A					)
                    if ord(_A					) in (
                        KEYMAP["insert"] - 1 << 9,
                        KEYMAP["delete"] - 1 << 9,
                        KEYMAP["pg_up"] - 1 << 9,
                        KEYMAP["pg_down"] - 1 << 9,
                    ):
                        WIN_CH_BUFFER.append(chr(126					)					)
                    SCREAMING_SNAKE_CASE							:							Union[str, Any]								=      chr(KEYMAP['''esc''']					)
                except KeyError:
                    SCREAMING_SNAKE_CASE							:							Optional[Any]								=      cha[1]
            else:
                SCREAMING_SNAKE_CASE							:							Tuple								=      ch.decode(_A					)
        else:
            SCREAMING_SNAKE_CASE							:							List[str]								=      WIN_CH_BUFFER.pop(0					)
    elif os.name == "posix":
        import termios
        import tty

        SCREAMING_SNAKE_CASE							:							List[Any]								=      sys.stdin.fileno()
        SCREAMING_SNAKE_CASE							:							Optional[Any]								=      termios.tcgetattr(_A					)
        try:
            tty.setraw(_A					)
            SCREAMING_SNAKE_CASE							:							int								=      sys.stdin.read(1					)
        finally:
            termios.tcsetattr(_A      ,		termios.TCSADRAIN      ,		_A					)
    return ch







def 							UpperCAmelCase_(  ):



    """simple docstring"""



    SCREAMING_SNAKE_CASE							:							int								=      get_raw_chars()
    if ord(_A					) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
        return char

    elif ord(_A					) == KEYMAP["esc"]:
        SCREAMING_SNAKE_CASE							:							str								=      get_raw_chars()
        if ord(_A					) == KEYMAP["mod_int"]:
            SCREAMING_SNAKE_CASE							:							List[str]								=      get_raw_chars()
            if ord(_A					) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(_A					) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
                return chr(ord(_A					) + ARROW_KEY_FLAG					)
            else:
                return KEYMAP["undefined"]
        else:
            return get_raw_chars()

    else:
        if char in string.printable:
            return char
        else:
            return KEYMAP["undefined"]

'''simple docstring'''




import unittest

import numpy as np
import torch

from diffusers import PNDMPipeline, PNDMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class 				a__(					unittest.TestCase	):


			'''simple docstring'''






			@property
			def 							a_       (   self):




					"""simple docstring"""


					torch.manual_seed(0)
					lowerCAmelCase   					=  UNetaDModel(
					    block_out_channels=(32, 64)       ,    layers_per_block=2       ,    sample_size=32       ,    in_channels=3       ,    out_channels=3       ,    down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")       ,    up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")       ,    )
					return model







			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.dummy_uncond_unet
					lowerCAmelCase   					=  PNDMScheduler()

					lowerCAmelCase   					=  PNDMPipeline(unet=__lowerCAmelCase       ,    scheduler=__lowerCAmelCase)
					pndm.to(__lowerCAmelCase)
					pndm.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase   					=  torch.manual_seed(0)
					lowerCAmelCase   					=  pndm(generator=__lowerCAmelCase       ,    num_inference_steps=20       ,    output_type="""numpy""").images

					lowerCAmelCase   					=  torch.manual_seed(0)
					lowerCAmelCase   					=  pndm(generator=__lowerCAmelCase       ,    num_inference_steps=20       ,    output_type="""numpy"""       ,    return_dict=__lowerCAmelCase)[0]

					lowerCAmelCase   					=  image[0, -3:, -3:, -1]
					lowerCAmelCase   					=  image_from_tuple[0, -3:, -3:, -1]

					assert image.shape == (1, 32, 32, 3)
					lowerCAmelCase   					=  np.array([1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0])

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







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


			'''simple docstring'''






			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  """google/ddpm-cifar10-32"""

					lowerCAmelCase   					=  UNetaDModel.from_pretrained(__lowerCAmelCase)
					lowerCAmelCase   					=  PNDMScheduler()

					lowerCAmelCase   					=  PNDMPipeline(unet=__lowerCAmelCase       ,    scheduler=__lowerCAmelCase)
					pndm.to(__lowerCAmelCase)
					pndm.set_progress_bar_config(disable=__lowerCAmelCase)
					lowerCAmelCase   					=  torch.manual_seed(0)
					lowerCAmelCase   					=  pndm(generator=__lowerCAmelCase       ,    output_type="""numpy""").images

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

					assert image.shape == (1, 32, 32, 3)
					lowerCAmelCase   					=  np.array([0.1564, 0.14645, 0.1406, 0.14715, 0.12425, 0.14045, 0.13115, 0.12175, 0.125])

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




